no more refactoring

supports all code languages and stacks

a flexible system of permissions and rights

an environment that can be launched anywhere

all stages of development on a single platform

a fully operational backend engine

a ready to use storage and data management environment

business logistics and scripting in one space

Thanks to the minimal unit of essence - a link, the reaction code isn't tied to the API, but to associative events (insert/update/delete), which react both to the events of the selected types of links and to the events of the links enabled via the selector. This allows you to create associative packages containing associative dialects tied with behaviors in any language.

Deep.Links orchestrates executable code in docker and soon in lxc containers. A simple adapter published as a docker image allows you to create your environment for your language and technological stack. Additionally, the executable code is simply written into the associative memory within the associative packages, which are properly connected to the links that describe the rules for code execution and isolation.

The associative system of rules makes it easy to test if one link has the permission to perform some action over another, that will be depicted as a third link. Rules use associative selectors to specify the ranges and criteria under which the rule applies. This makes associative rules a universal way of describing the rules and rights, as well as permissions on a business logic level.

If you have a docker on your system, deep.links can be deployed automatically in a Mac/Linux/Windows environment by following the provided instructions. We will soon offer a convenient solution for automatic distribution of storage and computational resources for multiple deep.links deployed in the cloud, and automatic orchestration within our Deep.Space project.

We are developing the Deep.Case associative space project. The alpha version of the application is now available as a web application that is deployed automatically with Deep.Links, as well as a stand-alone app for Mac/Linux/Windows based on Electron. The application is able to install Deep.Links as long as there is a Docker in the system. We are currently working on a beta version of the application, with a new design, extensible UI, that utilizes react-components as a way to modify the visualization method and environmental behavior of the client handler's connections with the tsx-code contained within associative packages. Upon release, the app will also run in cardova/capacitor environments on iOS/Android with equal functionality. We are in the process of developing an app build centered around NodeOS.

After running Deep.Links, it can independently control ports and routers, bind handlers to them in any programming language. Essentially, it already represents a full-fledged environment for essence storage and permission management. Of course, you can build your own back-end system using Deep as a storage environment, but considering of associative packages with super compatibility properties, that won't make much sense.

Associative memory can be used to describe any data model. To work with the link ranges, a system of trees is provided, which means that you don't have to make infinite traverse/joins in the structure. You are able to perceive the tree-like memory structures as flat, already indexed space, where the relationships are pre-considered.

The associative package contains:

Links that declare the types of Links that the package will operate with (as dialects).
Code async handlers executed in the back-end that are dedicated to the types of Links, knowing only their types of connections in advance. In this lesson, you can ignore the business logic, as it is already covered by the system of associative rights.
The client handlers code, which expands the Deep.Case interface, does not prevent it from being used while building your apps, for example our Deep.NextJS solution for building cross-platform applications like Deep.Case itself.

Deep.Case

pre alpha version

GitPod

(cloud demo)

Install

(electron)

Operational environment

Blurring the line between your desktop and your mind-space

Imagine an abstract space in which, at first, only actions with links are possible. With Deep.Case you can be immersed in the data as if it's an extension of your own thoughts. Anchor links around you and configure their behavior. Deep.Case can be utilized by analysts as a data workspace or as a space for assembly. Project management and status monitoring are also viable options. This is an extendable environment built on d3/threejs/AFrame.

On one hand, Deep is a system that embodies the idea of Data Driven Development because it is built upon an associative data space. At the same time, the data is split into atomic elements and is represented as a minimal unit of essence - the associative link. This allows to depict any semantic, logical and abstract constructs in a single dialect for memory operations. Instead of creating a perfect language or a perfect database, Deep is an ideal associative environment with an interchangeable core. This means that it can contain a multitude of competing implementations of databases and API access languages.

A brand-new programming paradigm

We have built a Meta language free of semantic predisposition

Any and all languages and stacks

You can write your ExecutionProvider for any programming language

In Deep the code is stored in Links and is capable of processing data events. For instance, it is possible to process events triggered by Links of a certain type as well as utilizing strict selectors from an array of trees via a WHERE-like syntax with support of join and/or traverse mechanics. The code can be written in any language compatible with any ExecutionProvider which is available as the DockerImage for our standard GQL API. And the code will be launched in its DockerImage that is linked to this ExecutionProvider in the database. Official in-transaction handler support will be added soon, as well as systems that will enable to run code on remote devices, including microcontrollers.

No longer are you forced to describe the business logic and restrictions with code. Now you can just define only the operation symbols you need, attach a subject-object-action system using a where-like syntax that will analyze the context upon completing an operation or a rights check. You will always know if there are rules allowing the execution of a single action or any operation using a GQL inquiry. This will keep business logic completely separate from coding decisions.