ATOM 4 VAR

A system based on the Atom platform can also be implemented by our representative – reseller (VAR).

From the user’s perspective, the most important part of a system using the Atom platform are the separate, atomic modules developed by our company. Our systems are running in very demanding environments, which is why we decided it would be easier to develop all of the source code in a single place so that the client can be certain that the modules are created by people who are experts in the Atom platform. This way, our client is guaranteed that the modules are fully compatible with the platform itself and are optimised for maximum performance.

MODEL FOR COOPERATION WITH VARs MORE

Obviously, it is rather impractical in today’s world to create an IT system from scratch. This would be very expensive, and it would involve many risks.

That is why our implementations are based on our own Atom platform, which is used to create dedicated solutions for specific clients. The platform (which is a finished product) is used to run the individual modules to perform various atomic actions. Our system can combine small modules into full processes capable of performing even very complex business operations.

There are many platforms on the market that can be used to run various systems. However, in most cases, it is necessary to first obtain complicated knowledge as to how they are designed. This prolongs the implementation and tests. Programmers who create such modules have to obtain such knowledge through their own efforts. This, in turn, means that even if the platform is good, the gaps in the knowledge or experience of the programmer may make the overall system ineffective, and its implementation will entail a large number of risks.

In our model of cooperation, however, all of the programming work is done by us. The source code for the individual modules is created by our own developers, who are perfectly familiar with the Atom platform. This way, we can fully utilise the potential of the platform.

Most importantly, however, such modules perform certain small, “atomic” functions. For instance, if the system requires the generation of data based on data sent by email in compressed and encrypted files, the receipt of the emails, decompression, decryption and, finally, processing will be performed by completely different atomic modules.

This way, our clients (or resellers) can configure the entire system on their own by creating an almost limitless number of combinations from the individual atomic modules to form more complicated processes. All this can be done without having to write a single line of code in any module.

Also, each module can be reused in multiple processes. What we actually deliver, then, is essentially a readymade system of bricks. It is our client or reseller that chooses how to use these bricks to build any IT solution.

GENERAL TERMS FOR COOPERATION WITH VARs MORE

In the actual implementation, our partner can use the Atom platform, without any involvement on our side, to:

Fully configure the entire platform and all modules using a convenient, standardised configuration interface available via the web browser. The configuration can be performed remotely or at the premises of the client.
Use the modules we have created to build more complex tasks with various associations between the modules.
Plan the conditions and time for the initiation of specific tasks – the platform will automatically run suitable modules at the right time or based on the associations between tasks and processes, in accordance with the configuration.
Run modules on suitable servers used by the system.
Manage server load (load balancing).
Handle emergencies, e.g. run converters/micro-services on a different server if the previous server fails.
Monitor the operation of the system.

It should be emphasised that the system only has to be configured once – afterwards, its operation is fully automatic and does not require any supervision (it is unattended).

Every company wishing to become a VAR has to sign a suitable contract and undergo training so that it can professionally complete the entire implementation process at the premises of the end client. Contact us if you are interested in this opportunity.

COOPERATION STAGES MORE

Analysis. Analysis of the needs and problems of our client, including an analysis of the conditions in which the software will be used. In particular, the analysis can be performed by our company, or it can be carried out only by our local partner, after suitable training.

System design. The design consists of two parts:

1. General concept of the system. This can be prepared directly by our local partner and then verified by us. The concept does not describe the detailed architecture of the system – it only presents the general way in which the client’s expectations are to be met (without the breakdown of the entire system into modules).
2. Detailed design of the modules. This part of the design is created exclusively by our company. We use our knowledge of the capabilities of the Atom platform to design all modules, user interfaces and data exchange and data processing methods. This way, our local partners receive a full description of the “bricks” they will have at their disposal to configure the processes directly at the client’s premises.

Our programmer teams implement specific solutions, creating specific modules to be run on the Atom platform. This is where we make use of all of our knowledge about the design of mass capacity systems, making sure that all IT solutions are optimised from the start. Also, the modules are created by people who are experts in the Atom platform and who can use the platform’s potential to the fullest.

Tests:

We perform all kinds of tests of each module ourselves.
Upon request of our partner or client, we can also perform full end-to-end tests based on suitable test scenarios.

Installation. Our local partners install the Atom platform and modules on their own, configure them and conduct suitable training for the end users and administrators. Upon request of the client or partner, the installation can also be performed directly by our company.

SLA: In-guarantee and out-of-guarantee after-sales service. Our systems receive full support. We believe that this is the most important part of the cycle because software is created only once, but it is then used continuously. That is why we are determined to make sure that our clients receive the proper support. Our specialists are at your disposal for all kinds of work, whether related to troubleshooting or modifications. The modifications may result from changes in the business requirements, but also, for instance, from a change in the volume of the processed data.

Furthermore, we will provide free service for our system throughout the term of the contract for in-guarantee and out-of-guarantee after-sales service. All errors will be eliminated under the contract, without any extra fees, for as long as the contract remains valid – with no initial restrictions.

Our local partners or clients can also modify process definitions on their own, using the bricks we have delivered, without any involvement on our part. Our company needs to be involved only when it is necessary to alter the source code of a specific module. That is why our local partner will provide support concerning the configuration of the modules, and we will take care of the implementation of the Atom platform and all of the modules we have delivered.

RESPONSIBILITY MATRIX MORE

Stage	dmt	Partner
Analysis	optional – upon request	YES
System concept	optional – upon request	YES
Detailed design	YES
Implementation	YES
Tests of the modules	YES
End-to-end tests	optional – upon request	YES
Installation of the Atom platform	optional – upon request	YES
Installation of the modules	optional – upon request	YES
Configuration of the Atom platform	optional – upon request	YES
Module configuration and process setup	optional – upon request	YES
In-guarantee and out-of-guarantee after-sales service concerning process setup	optional – upon request	YES
In-guarantee and out-of-guarantee after-sales service concerning the Atom platform and modules	YES

ATOM ARCHITECTURE MORE

ATOM ARCHITECTURE

Micro-services (modules) run on the Atom platform are small, independent blocks of executable code. Normally, there are many different micro-services of the platform running within a single system, created specifically for the particular implementation. Examples of tasks performed by the micro-services include:

importing files,
converting files,
processing data in the Atom_Convert database,
communicating with other systems or modules,
graphic processing or text recognition,

etc.

It should be emphasised that there is no single, definite specialisation of the Atom modules. Modules in different systems or modules within a single system can be very different in terms of complexity and the type of tasks they perform.

Many different modules can be run at the same time on a single physical or logic machine. Each such module is run together with the separate, dedicated configuration. The module together with the configuration is referred to as a process.

Each module may be suitable to be run on multiple machines at once or in several instances (processes) on a single machine. The machines and the number of instances where the module should be run are selected by the Atom platform based on the entered configuration.

- AtomRunTime is a component of the Atom platform that runs and manages the modules of the platform running on a single machine. Only one AtomRunTime is active on a particular machine intended for the system, and it is running at all times (in the standby mode, ready to activate the converters of the platform when necessary).
- AtomRunTime creates suitable conditions for the operation of the converters on the platform – it feeds them their configuration, receives their logs, etc.
- The Atom platform (understood as the entire grid/cloud) may include any number of machines, and AtomRunTime has to be installed on each such machine.
- AtomMonitor is an auxiliary component that monitors the operation of the AtomRunTime and AtomLoadBalancer components running on the same physical or virtual machine. If, for some reason, AtomRunTime or AtomLoadBalancer fail, AtomMonitor will restart them. This monitoring works both ways – if AtomMonitor fails, it will be restarted by the AtomRunTime or AtomLoadBalancer component running on the same machine.
- AtomLoadBalancer is a special component that always runs on precisely one machine as part of the Atom platform. Its function is to:
  - Monitor the operation of the entire system – all instances of AtomRunTime and AtomMonitor communicate with this component, transmitting information about their operation. Such information is also submitted by the modules via AtomRunTime. AtomLoadBalancer can detect certain types of emergencies and initiate suitable actions, e.g. if one of the system servers fails, AtomLoadBalancer can run the modules whose operation was interrupted on a different machine.
  - Distribution of the load among the available servers – if it is necessary to run another module (or another instance of one of the modules already running), AtomLoadBalancer will indicate the optimal machine for this purpose (e.g. the machine with the smallest load or suitable parameters).
- AtomConsole is a web application designed for the operator to monitor the operation of the Atom platform. The application displays system logs and other information about the running of the system. It can also perform emergency operations, such as stopping or initializing one of the components of the platforms.
- PTRConfig is a web application used to configure the operation of the entire PTR platform and individual modules. In particular, it can be used to:
  - Define calendars and regions (time zones).
  - Group individual processes into more complex tasks.
  - Define associations between the tasks.
  - Define conditions for the running of tasks – running time.
  - Modify the configuration of the converters – the configuration of the converter, stored in the database in the form of an XML file, is displayed by the application as a user-friendly form where the operator can modify the parameters.
- Communication between the individual components of the system takes place directly or via a database. Examples of direct communication include communication between the AtomRunTime application and the particular process (i.e. a module run with a specific configuration). The AtomRunTime application may have various effects on the operation of the module, in particular, it can:
  - Run the module and send it the operating parameters of the process (in the XML form).
  - Receive the results of module operation from the module.
  - Stop the module (order the converter to stop performing the conversion task at any time).
  - Check if the converter is working.
- The Atom platform uses a three-layer architecture:
  - The presentation layer, i.e. AtomConfig and AtomConsole, developed as web applications.
  - The business layer consisting of the web services incorporated in the platform: AtomLoadBalancer, AtomRunTime, AtomMonitor and relevant modules.
  - The database layer consists of relevant SQL servers with an embedded logic in the form of a stored procedure. In order to ensure maximum performance and scalability of the Atom platform, it is recommended to use the VoltDB database.
- The Atom platform enables simultaneous access of multiple users to its web applications (AtomConfig and AtomConsole), without, however, permitting the configuration of a single component at the same time by different users.
- For instance, two users may configure two different tasks, but two users certainly cannot modify the configuration of the same task at the same time.
- The user interface of AtomConfig and AtomConsole is available in two languages: Polish and English.
- The configuration database of the platform will be used to store information about the language selected by the user.
- The multilingual interface is implemented in such a way that it will be fairly easy to add further languages in the future.
- All information logged by the Atom platform is available only in English.
- Parallel processing is one of the primary features of the Atom platform.
- Parallelism enables the scalability of the platform, greatly contributes to its reliability and, most importantly, significantly reduces processing time.
- The parallelism of the Atom platform is implemented on several levels:
  - Level of multiple processing servers.
  - Level of multiple processes running on a single machine at the same time.
  - Level of the parallelism of tasks performed within the task groups.
- Scalability is one of the primary features of the Atom platform.
- If the capacity of the servers that process the data at a certain point during the lifetime of the system becomes insufficient to complete processing within a specific time window, the client will only have to add another server and configure the Atom platform to use it (i.e. install AtomRunTime and AtomMonitor on that server). Naturally, scalability can also be achieved by extending the configuration of the existing server.
- Atomic structure is a property of the modules written for the Atom platform, which are designed in such a way as to perform the most atomic functions possible.
- For instance, instead of creating a single, universal module to import files in different formats, we will create a number of special atomic import modules equal to the number of different standards of the imported files.
- All modules on the Atom platform share a common framework, which is responsible, in particular, for the running, communication and configuration of the modules. Thanks to such a framework, the creation of a new module only requires the preparation of code that implements the business logic of that module.
- The atomic design of the module reduces the need for modifications, and if any modifications are needed, they will be much easier to implement due to the simplicity of the module itself. The atomic structure also reduces the amount of work required, for instance, to complete the acceptance tests performed by the client, regression tests, etc.