How does the development process work, and where you can put your hands to

Any ERP-system requires the developer to:

describe the structure of the objects which will store the information;
create (if complex display logic is required; simple forms are automatically generated) forms to manage these objects;
describe their behavior, that is to write the functions of the conversion from one to the other, and handle a variety of events (save, delete etc).

The objects that are most important for the implementation of the business logic (and used in Ultimate Solid) belong to these three types:

dictionaries;
documents;
totals.

Besides there are:

tabular parts;
link tables;
conditions of the documents;
constants;
translations (internationalization support);
and others — a total of about 40 kinds of objects.

The structure and description of these objects form the metadata of the specific solution implementation on the Ultimate Solid platform.

Dictionaries are used to store static data. As a rule, this data is about the real objects.
Naturally, their purpose is not limited to this, but we won’t overload this ad text by listing everything.
In the simplest case the dictionary of the database is represented by one table — for example, the table listing the storehouses or products.

Documents are the objects that contain information about the performed actions — the sale of the products, for example.
Those are some fairly complex entities that have a rich internal structure; their complexity is due to the rigid practical requirements to the volume and heterogeneity of the stored information.

Totals. There are parallels with the accounting terminology: a total is the development of the account idea. There are parallels with OLAP: a total is the development of the idea of a cube.
The totals are used for storing and keeping records of the measurable indicators of the automatable area.
For example, the remaining stock at the storehouse or the contractors’ debts.

The totals get changed by the accounting records (transactions) – again, this is similar (but not identical!) to the accounting.
The list of records can be represented as a fact table, if you use the OLAP-terminology.

Records, in turn, are generated by scripts that get activated when saving any document and that, in fact, are written by the developers. In addition to the scripts used for the records’ generation, a developer can create the scripts that run when you delete or create a document or a dictionary, or they can be simply accessed from the user menu.

The abstractly formulated business logic of an automated enterprise gets practically transformed into the scripts, triggered at certain moments according to the relevant events.

Presently the Ultimate Solid has 23 types of events and, therefore, as many of the scripts that are potentially run by them.

preparation of the data for printing;
servicing of web-requests according to SOAP/REST protocols;
records’ generation;
complex reports’ generation;
unit-tests;
commands over the document;
commands over the list of documents;
commands over the dictionary record;
commands over the list of dictionary records;
processing of the dictionary record’s events;
processing of the document’s events;
interfaces;
services;
providers of the columns for reports;
periodic tasks;
totals’ drivers;
unbound commands;
common handler of the dictionary’s events;
common handler of the document’s events;
handler of the total’s events;
mobile interfaces;
mobile services;
transactions’ validators.

Click to open the list

As a result, the developer’s activity is determined by the sequence of actions:

to describe the structure of objects — dictionaries, documents, totals and other metadata;
to transcribe the business logic into scripts;
to implement the screen logic — special forms for data display or record;
to complete checks (also by means of regression tests);
to transfer to testing.

The scripts are written in the embedded development environment in the C# language; the editor supports the auto substitution (analogous to IntelliSense in MS VisualStudio). The version control system allows two (or more) developers to make independent changes to the business logic. "Independent" means that these conventional two (or more) developers can make changes to the scripts simultaneously, without affecting the result of each other’s work.
It is possible to change the objects’ structure independently, too, by following certain restrictions described in the documentation.
There is a useful feature of the built-in versioning system — it is easy to understand what factual changes were made. Tracking of the changes and the fulfilled change requests can dramatically reduce the time needed for testing without sacrificing the testing quality and completeness.

The screen logic of the main desktop-client is implemented as the WinForms application forms.
You can draw them anywhere, but the best and most convenient option, in our opinion, is to do it in VisualStudio.
You can use Xamarin Studio in order to create a logic screen for Android devices. Naturally, the development is carried out not in a random way — it is based on the provided components and tools.