What can you do in the current version?

Boundaries between

We plan to develop a universal system with the ability to create complex applications where a low-level programming language is usually required. On the other side, a universal system must allow the development of simple applications and scripts. We've implemented such a system and you can easily mix low and high level code in your applications.

The platform was designed to support a lot of platforms, i.e. to be a cross-platform solution. Because of that, the platform has minimal dependency on the operating system and uses only simple OS functions that exist in any OS. Currently, the Elastic Studio (our IDE) and all applications developed in the Platform, are running on Windows natively and on MacOS/Linux with Wine. Furthermore, now we're working to add the support for iOS/Android. Besides, we plan on adding object marshalling which allows to build applications distributed between several devices as a single app.

The platform's architecture is designed to support the same code with various syntax. I.e. a developer who writes in Basic will see Basic code, not PHP or C++. We plan on reaching this goal in the nearest future. As of now, we were able to implement the support of the programming language that is compatible to both C++ and PHP.

While programming, when the source code is divided into many files, developers waste a lot of time to work with them. Our platform already offers a more useful system to reduce the development time. All source code is stored into a single codebase and is split into libraries, classes, functions and variables. The source code of any function can be opened in a separate tab within the Elastic Studio. It allows easy learning of the source code and editing of the neccessary source code parts thanks to the clear code presentation system. It greatly reduces development time and is very useful; everything is concentrated in a single place. Besides, such a system allows to easily include involved classes and libraries into a project.

Because of the platform's abilities there is a whole class of applications that can be developed without a single row of code. We will improve this kind of apps. You can watch the video below with an example of building one of such applications.

Watch the video

See how you can create an application without programming in The Elastic platform, our IDE

The integration of the database and the programming language also allows to reduce the development time. You can describe classes in the programming language to join them to the database's node inside the Elastic Studio, and the database structure is already getting created.

Objects of these classes are stored, selected and inserted directly using the database. Moreover, you don't need any ORM with complex usage process!

The database engine is designed in a way that there is no difference between local and remote databases in the platform. Even the installation process of the remote database only requires port definitions and running a server script.

The platform's architecture was designed to have a lot of versions under different OS/devices, but with the same code. From the start we plan on applications having a web version without the need to change to source code or to build a separate application. We're already far on the way towards reaching that goal.

We're developing a cloud version of the Elastic Studio right now. In the cloud version, all developers work with a single codebase stored on the server in realtime. All functions of the source code have read/write privileges. Developers can communicate with each other like in Slack and the whole application life cycle is right in front of them. Such a system allows very rapid development and the usage of modern technics like Agile and Crum. It increases the source code safety and improves the development process.

We already feel the breath of virtual reality. We assume that in the future, application interfaces will be adopted to be usable in the virtual reality. With that in mind, a development tool must have good support of 3D technology. Our platform already has such support and we will improve it.

Calling function by name, by pointer and by inheritance mechanics

Calling function by name. You can use any class, but you have to use variant variable:
$MyPanel = new TPanel;
MyPanel->AnyFuncName(var1, var2);

Elastic has full-compatibility with C++ inheritance object model. Thus, you can use virtual functions and C++ function pointer variables.

Native compilation

The platform compiles source code to native everywhere it's possible. In case of high-level programming language usage, the platform's compiler makes native calls into the executive layer which manages high-level functions.

Classe attributes

The platform allows not only to create, compile and use classes on the fly. Any class and its members may have any number of attributes. It helps create new solutions easy. I.e. database structure creation algorithm uses class attributes.

Web support

The support of web-applications has been present in the platfrom from the start. Because of PHP compatibility, the platfrom supports $_GET, $_POST and $_SERVER arrays, which are required to work with websites using Apache. Currently, we're developing the app server with the support for HTTP/HTTPS. The object model from C++ on one side and dynamic objects. arrays and calling functions by name on the other side, already allow to build useful frameworks. Also, we plan on adding Javascript support.

ElasticG techonolgy

The technology allows to easily manipulate the data in the database. Binding between the database and the widgets of the form is performed via this technology. Developers need to set a data operator for every widget and for the data operator they only need to set a member of the class.

Easy to develop own widgets

The system of form control has a clear logical struture and you can easily develop your own controls. The developer only needs to create a class with event handlers. Every event has its own hadnler that is a function in the class, i.e. OnMouseMove. Widgets call platform painting function to draw graphics for the widget.

Calling DLL functions

The platform allows to easily use DLL functions. There is a function to get a point to a given function of DLL or even the pointers to a set of functions. The function is declared as usual in C++. The current OpenGL implementation uses such set of pointers.

Functions to work with 3D

The platform has embedded variable types and functions that are required for 3D. I.e. there is a function to calculate polygon normals, the point used to get a dot product, because vector type is embedded into the platform.

On the fly module loading

The platform has its own executable file format. It allows to load/unload executable modules while an application is running. The platform has an embedded compiler class. In that way Elastic developers have the ability to allow users of their application to extend the app with user modules.

C++ compatible inheritance model

The object model is C++ compatible, with the only exception - you don't have to use function declaration, but you can use them. You can use virtual functions and operation permits visibility. The second exception is that classes use smart pointers and a garbage collector, but you can use native classes. Native classes require memory allocation/deallocation absolutely equal to C++ classes.

Encryption connection

We use the OpenSSL library with all cryprographic functions. We have own data transfer protocol that is encrypted, but it still uses this library.

Data encryption in the database

From the start we were planning to have AES-256 data encryption in the database engine. Thus, if somebody encrypted the data and forgot the key, nobody would be able to decrypt the data until a quantum computer appears. The programming language has all the neccesary encryption functions, lika sha512 or md5.

Dynamic arrays and vectors

The platform supports dynamic arrays compatible to PHP arrays. You have an array() function and the ability to use string indexes. Every array cell can contain another array. Arrays are used in database queries.

Moreover, you can use native arrays like in C++, i.e. DWORD* These arrays require explicit memory allocation/deallocation.

Multi-threading

We assume that every application has several threads. Thus, the platform has the neccessary function for thread creation and synchronization. Besides, the platform has the dynamic section of global variables. It means that you can run several copies of the same code inside the same application. The app server with http/https will also work exactly like that.

Garbage collector

If a developer doesn't use low-level programming, the platform's executive layer controls the memory usage and releases object/array memory when they are needed. I.e. all local variables are released on function exit. But if a local array or an object moves to a global variable or a class variable, it's not going to be released.

Stack overflow protection

If a developer uses high-level functions of the platform, the executive layer uses the special stack. Because of that, it's impossible to force the code execution by stack overflow, as is often done by app crackers.

However, you can define the native stack usage for a function. It's neccessary for DLL functions or the fast execution code.

Macro language

The programming language doesn't support C++ templates yet. Instead of them, you can use macro functions. There is support of #ifdef/#endif directives. Besides, the compiler is embedded into the plaftorm and you can generate, compile and load the code on the fly.

String functions, JSON

We haven't yet implemented the support for regular expressions. Of course, we'll do that in the future. But you are already able to use a lot of string functions and you can easily work with texts. I.e. string functions used for forming $_GET array from an URL. However, for the support of JSON format another platform feature is used. With this feature you can parse any text and syntax. You can look at the source code of JSON class inside the Elastic Studio.

Assembler support

The platform has embedded assembler. You can get a pointer to any variable into eax register. Now we're adding the support to use native variables from the assembler directly. The Elastic Studio has embedded disassembler and developers can see the compiled source code. We will extend the assembler support and you can use assembler even on mobile devices.

Form widget/controls hierarchy designed to support HTML

The design of the platform has been compatible with HTML from the start. Thus, there is the hierarchy of form widgets/controls that can be translated to HTML-text. Every widget already has the handler function that creates the HTML-text widget. It allows to easily transform desktop apps into web versions.

Several very important goals for us

For us, as for many other developers, the development speed is extremely important. We've had experiences with the platform where the development speed was 9 times faster than in C++ and 3 times faster than in PHP. The speed of development will be increased after we finish the support of other platform's features.

For us the usability of a development tool and the comfort in development are very important. We haven't fully reached this goal with the platform yet and will continue to improve these aspects.

The safety of data storage, security in data transfer, the safety of source code are priority tasks for us. Therefore, our database engine can encrypt any data in the database. The data transfer channel is encrypted and the cloud version of the Elastic Studio will have an ability to set read-write privileges for any given function.

From our experience we know that large-scale applications often start from a small program. Thus, from the start of the platform's delepoment we assumed that applications will extend, will require many servers and support for larger number of users, and it should not lead to having to redevelop the whole application from scrath. We try to give developers all the tools required to build highly scalable and robust applications.