Introduction    ▶    All in One    ▶    Language


"do:IT" réunit les atouts des différents langages en un seul
pour devenir le langage unifié de conception et de mise en œuvre de platforme intelligente.


Comme indiqué sur son logo, "do:IT" est un langage de description basé sur la notation JSON pour favoriser sa réutilisation et son introspection par d'autres outils.

Dans cette vocation descriptive, le langage "do:IT" est un langage naturel de description d'algorithme (LDA : Langage de Description d'Algorithme).

Prenons les descriptions classiques ci-dessous :
✓  SI …
✓  REPETER … TANT QUE …
✓  TANT QUE … FAIRE …
✓  POUR … REPETER …
✓  SELON … FAIRE …
Contrairement au LDA, les descriptions en "do:IT" sont exécutables mais ne nécessitent pas de génération de code.

En plus, "do:IT" introduit des comportements à chaque flow, ex : trace, monitoring, parallélisme, sécurité, etc.











Il était une fois mon LDA ...


L'approche "Flow-based Programming" du langage "do:IT" pousse la modularisation de l'implémentation jusqu'à la limite de l'imagination.
Prenons le cas du site web de "do:IT" :
✓  Le template "web-template-std.panel" des pages
✓  et la page "me.page" qui la dérive






La capacité contextuelle des langages de scripting shell est importée dans "do:IT" avec une approche contextuelle plus avancée dite "context path" :
  • "code:entry" dont :
    • ✓  code : Designe le code de la catégorie de context, ex : ctx pour le contexte standard, obj pour l'object en cours (this), sys pour les informations du système, app pour les informations de l'application, ...
    ✓  entry : Designe l'attribut du contexte, ex : "app:name" pour le nom de l'application en cours
  • "code:entry[index]" dont :
    • ✓  index : Designe l'index d'accès à un attribut de type ARRAY ou LIST
  • "code:entry->key" dont :
    • ✓  key : Designe un sous attribut ou une clé de 'entry'
    Le "context path" est nécessaire pour accéder à une référence dans les contextes "do:IT"
  • { "ref" : "code:entry" } ou pour le formatage contextuel d'une valeur "${code:entry}"

    • Pour le formatage contextuel des valeurs, "do:IT" propose des syntaxes variés :
  • "${code:path%default_value}" dont :
    • ✓  default_value : Designe la valeur par défaut si le référence n'existe pas ou NULL
  • "${code:path@TYPE%format@PADDING%padding_size%padding_char@CASE}" dont les sections par ordre :
    • ✓  La section TYPE%format : Designe le type et le format d'affichage, ex : DATE avec 'dd/MM/yyyy'
    ✓  La section PADDING%padding_size%padding_char : Designe l'alignement 'padding' (NONE, LEFT, RIGHT), le caractère de remplissage 'padding_char' et la taille de remplissage par rapport à l'alignement 'padding_size'
    ✓  La section CASE : Designe la base de casse (NONE, LOWER, LOW/FIRST, UPPER, UP/FIRST)
  • Les sections peuvent être faites en desordre : "${code:path@case=CASE@padding=PADDING%padding_size%padding_char@type=TYPE%format}"


    • Prenons 2 exemples :

    For each item :
    -> 0 : J.A.R.V.i.S (Just A Rather Very Intelligent System)
    -> 1 : F.R.i.D.A.Y (First Realistic Intelligence Data Analysis Yielder)
    -> 2 : G.E.R.R.i.X (Generic Enterprise Reliable and Resilient Intelligent eXperience)
    For index :
    -> 0 : J.A.R.V.i.S (Just A Rather Very Intelligent System)
    -> 1 : F.R.i.D.A.Y (First Realistic Intelligence Data Analysis Yielder)
    -> 2 : G.E.R.R.i.X (Generic Enterprise Reliable and Resilient Intelligent eXperience)
    By index :
    -> 0 : J.A.R.V.i.S (Just A Rather Very Intelligent System)
    -> 1 : F.R.i.D.A.Y (First Realistic Intelligence Data Analysis Yielder)
    -> 2 : G.E.R.R.i.X (Generic Enterprise Reliable and Resilient Intelligent eXperience)
    *******************************************************************************
    Bonjour ! C'est 'Web-Site' ('do:IT' web site)
    -> sur 'ip-172-31-43-24.eu-central-1.compute.internal' (Linux - 4.14.177-139.254.amzn2.x86_64)
    -> ID du processus (PID) : 7756
    -> vous êtes sur '172.31.45.67' (CCBot/2.0 (https://commoncrawl.org/faq/))
    -> il est 02:58:32 (08/12/2024)
    *******************************************************************************
    Le language "do:IT" peut modéliser et manipuler les objets (OBJECT) et les énumérations (ENUM),
    Il supporte l'héritage d'objet (même en multiple).

    Prenons l'exemple ci-dessous :



    A noter qu'il est possible de manipuler directement les objets Java avec "do:IT"
    avec les flows NEW et INVOKE.
    Les capacités "Flow-based Programming" et "Aspect Programming" de "do:IT"
    lui permettent d'introduire facilement des comportements et des aspects plugables.

    Prenons les 2 cas d'aspect ci-dessous :



    		En prenant une instruction "curl" :



    		On peut brancher des comportements en amont "flw:before" et en aval "flw:after" de l'appel de module :



    		Ou poser un contrôle d'erreur "flw:catch" :

    "do:IT" dispose d'autres comportements additionnels par aspect comme la sécurité, le monitoring, les logs et les audits.
    "do:IT" peut rendre l'exécution d'une section d'instruction en parallel ou en concurrence.



    		En prenant la section ci-dessous :


    Puis on la transforme en section parallelisable, sans l'activer, "parallel NONE" :



    		En mode "parallel JOIN", on aura :



    		En mode "parallel concurrent FIRST", c'est à dire qu'une fois une instruction est aboutie "FIRST", les autres seront annulés ou interrompues :


    La section "parallel" dispose d'autres caractéristiques,
    ex : pool de thread (en local ou en global), intra-processus ou multi-processus (voire même multi-host).

    Sinon, les modules "PARALLEL" disponsent d'autres fonctionnalités avancées.

    "do:IT" étant à la fois descriptif et instructif, les données et les instructions se traduitent à des descriptions quelconques.
    De base, la description de donnée et d'instruction se diffèrent. Mais quand une donnée est typée en tant qu'objet exécutable ( "is" : "INSTRUCTION", "FLOW", "VALUE", "EVALUATION" ou "FUNCTION" ), elle peut être exécutée ou évaluée. Et pareil quand une donnée quelconque (ex : texte) est chargée en tant qu'objet exécutable ("DO" en tant qu'instruction ou "EVAL" en tant que valeur dynamique ou évaluation).

    Ce site web bénéficie largement l'aspect dynamique de "do:IT" car les fichiers .page et .panel sont des textes
    mais ils sont chargés en tant qu'évaluation de contenu.

    Observons les exemples d'invocation dynamique de 'FUNCTION' ci-dessous.

    Reprenons le type d'objet 'ACTOR' que nous avons dans la section 'Object-oriented Programming'.

    Il dispose de 3 attributs :
    ✓  'name' en tant que STRING et ne doit pas être NULL (required),
    ✓  'intelligence' en tant que STRING, avec comme valeur par défaut 'A.i',
    ✓  'sayHello' en tant que FUNCTION, avec comme valeur par défaut sa propre fonction 'sayHello'.
    Et d'une fonction 'sayHello'.

    Exemple - N°1 :
    Créons une instance d'object de type 'ACTOR' dans la variable 'iron-man'.

    Pour appeler la méthode 'sayHello', nous disposons de 3 possibilités :
    ✓  soit avec l'appel standard de fonction d'un object ( cf. Case-1 ),
    ✓  soit par reflexion en accédant à la fonction du type 'ACTOR' ( cf. Case-2 ),
    ✓  ou soit par référence à l'attribut 'sayHello' de type 'FUNCTION' ( cf. Case-3 ).
    Les 3 possibilités donnent le même résultat :
    -> Hey 'Tony STARK' ! You have 'J.A.R.V.i.S' !

    Exemple - N°2 :
  • Créons un objet de type 'FUNCTION' en tant que variable 'sayIntelligence'.
  • Changeons l'attribut 'sayHello' de l'objet 'iron-man' par la fonction référencée par 'sayIntelligence'.

    • En invoquant la nouvelle fonction référencée par l'attribut 'sayHello' de l'object 'iron-man', on a le résultat ci-dessous :
    -> Hello 'Tony STARK' ( by 'J.A.R.V.i.S' ) !

    Exemple - N°3 :
    Les 3 cas ci-dessous montrent les possibilités d'attachement dynamique d'une fonction à une instance d'objet quelconque :
    ✓  Appel de la fonction 'sayHello' du type 'ACTOR' en utilisant l'objet référencé par la variable 'me' qui n'est qu'une simple MAP ( cf. Case-1 ),
    ✓  Appel de la fonction référencée par la variable 'sayIntelligence' en utilisant l'objet référencé par la variable 'me' ( cf. Case-2 ),
    ✓  Appel de la fonction référencée par la variable 'sayIntelligence' en utilisant l'objet référencé par la variable 'iron-man' de type 'ACTOR' ( cf. Case-3 ).

    On a successivement les résultats suivants :
    Case-1 : Call type function using another object instance ( MAP )
    -> Hey 'Rivo RASOLOFOMANANA' ! You have 'G.E.R.R.i.X' !
    Case-2 : Function object using any object instance ( MAP )
    -> Hello 'Rivo RASOLOFOMANANA' ( by 'G.E.R.R.i.X' ) !
    Case-3 : Function object using any object instance ( ACTOR )
    -> Hello 'Tony STARK' ( by 'J.A.R.V.i.S' ) !

    La capacité de programmation dynamique de "do:IT"
    permet aux plateformes G.E.R.R.i.X d'avoir un niveau très avancé en généricité et en abstraction des plugins.
    Cette capacité est la base principale de l'enrichissement et de l'apprentissage de la capacité 'Automation Intelligence' de G.E.R.R.i.X.

    Découvrez les plateformes

    "do:IT" manipule nativement de même manière les données :
    les structures (MAP, JSON, XML), les séquences (LIST, SET, ARRAY, ITERATOR) et les objets (OBJECT, ENUM).

    Pour faire une abstraction des méthodes ou des attributs,
    "do:IT" n'oblige pas à recourir à la programmation orientée objet (Object-oriented Programming).
    Sa capacité contextuelle lui permet de se concentrer sur les données et d'orienter les traitements vers la structure au lieu du typage.
    Telles sont ses capacités Data-oriented et Data-driven.

    Prenons l'exemple des objets ci-dessous :



    		Avec les 6 objets présentés (S1, S2, S3, S4, S5 et S6), de formes géométriques différentes, on doit calculer leur espace d'occupation rectangulaire.

    Supposons que cet espace rectangulaire de l'ensemble est représenté par S :


    Pour faire simple, l'approche serait d'évaluer l'espace géométriques rectangulaire occupé par chaque objet (rectangle, cercle ou autre) en évaluant les attributs suivants :
    ✓  x : l'abscisse de l'objet que l'on peut associer au xTop de l'objet,
    ✓  y : l'ordonnée de l'objet que l'on peut associer au yTop de l'objet,
    ✓  width : la largeur occupée par l'objet pour calculer le xBottom de l'objet (xTop + width),
    ✓  height : la hauteur occupée par l'objet pour calculer le yBottom de l'objet (yTop + height).

    Ainsi on pourra évaluer l'espace S, avec le MIN (xTop, yTop) et MAX (xBottom, yBottom).



    		 Pour les objets rectangulaires, l'évaluation de x, y, width et height est évidente.
    On peut garder le type "RECT" :



    		Pour les cerles, l'évaluation de x, y, width et height nécessite une évaluation à partir du centre et du rayon (radius).
    Dans ce cas, nous allons créer des attributs évalués :


    Ainsi nous pourrons effectuer le traitement suivant pour évaluer l'espace S et ses couleurs :



    La programmation orientée objet (OOP) nécessite un héritage de type parent pour RECT et CIRCLE.
    Alors que la conception orientée donnée (DOD : Data-oriented) et la programmation guidée par les données (DDP : Data-driven),
    orientent la conception et la programmation vers la structure la plus adaptée au contexte.
    Etant le langage d'implémentation de la démarche "Platform-oriented Architecture",
    "do:IT" a été conçu pour répondre aux patterns de déclinaison Socle (Core) et Usage.

    Soit le Socle qui implémente de manière générique le pattern
    et l'Usage ne fait que configurer.    		 Soit le Socle qui spécifie et articule le pattern
    et l'Usage implémente ses spécificités.



    Afin d'intégrer l'Usage au Socle (Core),
    un (ou des) point(s) d'attachement des "plugins" doit être défini.


    "do:IT" étant un 'Dynamic Programming Language',
    il dispose des objets de type EVALUATION (en tant que VALUE) et FLOW (en tant qu'INSTRUCTION)
    pour définir les plugins d'intégration au socle.


    Prenons le pattern "FILE:RECEIVE"



    Description :
    Réception de fichier

    Paramètres :
    Element Type(s) Description
    FILE:RECEIVE FLOW Flow de réception de fichier :
    ✓  Sélection de fichier (par filtre)
    ✓  Validation de chaque fichier sélectionné
    ✓  Exécution d'instruction suivant le résultat de validation (accepté ou rejeté)
    File Filter EVALUATION Plugin de filtre de sélection de fichier dans le FILE:STORE
    File Validation EVALUATION Plugin de validation de fichier
    on Accepted File FLOW Plugin d'instruction à exécuter pour chaque fichier validé (cf. FILE:SEQ)
    on Rejected File FLOW Plugin d'instruction à exécuter pour chaque fichier rejeté (cf. REJECT:SEQ)

    Ci-dessous l'implémentation en "do:IT" du pattern "FILE:RECEIVE".



    Découvrez les autres patterns

    Grâce à son double aspect (descriptif et instructif),
    le language "do:IT" permet de decrire et de contrôler les différents niveaux de l'IT (Plateforme et Infrastructure)