IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Java Discussion :

Jolie, un langage de programmation orienté services


Sujet :

Java

  1. #1
    Chroniqueur Actualités
    Avatar de Bruno
    Homme Profil pro
    Administrateur systèmes et réseaux
    Inscrit en
    mai 2019
    Messages
    399
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Autre

    Informations professionnelles :
    Activité : Administrateur systèmes et réseaux
    Secteur : High Tech - Produits et services télécom et Internet

    Informations forums :
    Inscription : mai 2019
    Messages : 399
    Points : 7 763
    Points
    7 763
    Par défaut Jolie, un langage de programmation orienté services
    Jolie, un langage de programmation orienté services,
    il permet d'agréger directement les API de services dans un serveur Web

    Lancé en 2006 dans le cadre de ses études à l'Université de Bologne par Fabrizio Montesi, Jolie (Java Orchestration Language Interpreter Engine) est un langage de programmation open source pour le développement d'applications distribuées basées sur des microservices. Dans le paradigme de programmation proposé avec Jolie, chaque programme est un service qui peut communiquer avec d'autres programmes en envoyant et en recevant des messages sur un réseau. Jolie prend en charge une couche d'abstraction qui permet aux services de communiquer en utilisant différents supports, allant des sockets TCP/IP aux communications locales en mémoire entre les processus.

    Jolie est actuellement pris en charge par un interpréteur implémenté dans le langage Java, qui peut être exécuté dans plusieurs systèmes d'exploitation, notamment les systèmes d'exploitation basés sur Linux, OS X et Windows. Le langage est doté d'une sémantique formelle, ce qui signifie que l'exécution des programmes Jolie est définie mathématiquement. Pour cette raison, Jolie est utilisé dans la recherche pour l'étude de techniques basées sur le langage pour le développement de systèmes distribués, et il est également utilisé pour l'enseignement dans certaines universités.

    Nom : Jolie.PNG
Affichages : 118078
Taille : 6,4 Ko

    Si les qualités de Jolie en font un langage prisé dans le domaine de la recherche, notamment pour l'étude des techniques basées sur le langage pour le développement des services et systèmes distribués, il n’en est pas moins vrai que le langage n’est pas accepté par toute la communauté des développeurs. Au sein de cette communauté, certains professionnels du développement estiment que le langage qui cristallise les concepts de programmation de l'informatique orientée services sous forme de constructions linguistiques n’est qu’un langage de trop. Si l'on en croit du moins la réaction de cet internaute lors d’une discussion sur Jolie.

    « Qui veut réellement cela ? Les gens veulent de bonnes bibliothèques pour faire cela avec les langages qu'ils utilisent déjà, et non pas avoir à faire des compromis juste pour avoir un microservice. Remarquez que la page d'accueil donne de nombreux exemples des parties du code relatives aux services, mais absolument aucun exemple de ce à quoi ressemble la logique métier. En fait, même dans la documentation, le code d'exemple est minimal et trivial ».
    Pour un autre internaute, le langage est une autre forme de framework et, sans surprise, il a été développé en Java pour les utilisateurs de Java.

    « Je pense que cela peut devenir populaire pour les fans de frameworks Java. Entre eux, les gens peuvent se chamailler à propos de J2EE, Spring ou Quarkus, ou Oracle Fusion, Microprofile et une myriade d'autres. Mais l'idée centrale est que toute personne utilisant directement Java avec l'aide de librairies standard et tierces est un vieux fossile qui devrait être éliminé du projet/de l'entreprise ou, mieux encore, de la main-d'œuvre tout entière ».

    S’il est établi que Jolie ne fait pas l’unanimité, il convient de mentionner que le concept même du langage intéresse plus d’une personne. « Je le veux. Au moins l'idée. Je veux quelque chose qui ressemble à un langage de programmation (les plus courants) qui décrit et spécifie le flux d'une fonctionnalité, pas un YAML ou un fichu fichier XML, mais pas non plus un framework XYZ qui contient tous les détails de mise en œuvre. Peut-être que Jolie n'est pas ce que je veux et qu'il a plus de bagages que ce dont je suis actuellement conscient, mais il ressemble d'une certaine manière à quelque chose dont j'ai besoin », déclare Pedro Batista, un développeur Web. Voici, ci-dessous, quelques caractéristiques du langage Jolie :

    Penser en termes de services

    Jolie cristallise les concepts de programmation de l'informatique orientée services sous forme de constructions linguistiques. Les éléments de base des logiciels ne sont pas des objets ou des fonctions, mais plutôt des services qui peuvent être déplacés et répliqués selon les besoins. Une composition de services est un service.


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    type HelloRequest {
    	name:string
    }
     
    interface HelloInterface {
    requestResponse:
    	hello( HelloRequest )( string )
    }
     
    service HelloService {
    	execution: concurrent
     
    	inputPort HelloService {
    		location: "socket://localhost:9000"
    		protocol: http { format = "json" }
    		interfaces: HelloInterface
    	}
     
    	main {
    		hello( request )( response ) { 
    			response = "Hello " + request.name
    		}
    	}
    }

    Adapté aux microservices et aux API

    Jolie est un langage de programmation axé sur les contrats, qui place la conception des API au premier plan. Il prend en charge les communications synchrones et asynchrones. Les modèles de données sont définis par des types qui supportent le raffinement (en rouge dans le code ci-dessous), et les transformations DTO (Data Transfer Objects) sont gérées de manière transparente par l'interpréteur.


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    type GetProfileRequestType {
    	id:int
    }
    type GetProfileResponseType {
    	name:string
    	surname:string
    	email:string( regex(".*@.*\\..*") )
    	accounts[0,*] {
    		nickname:string
    		service_url:string
    		enabled:bool
    	}
    	ranking:int( ranges( [1,5] ) )
    }
     
    type SendMessageRequestType {
    	id:int
    	message:string( length( [0,250] ) )
    }
     
    interface ProfileInterface {
    requestResponse: // Synchronous RPC
    	getProfile( GetProfileRequestType )( GetProfileResponseType )
     
    oneWay: // Asynchronous
    	sendMessage( SendMessageRequestType )
    }

    Conçu pour l'ère du réseau

    Le code de Jolie est toujours contenu dans des services, que vous pouvez toujours faire passer de local à distant et vice-versa, sans altérer la logique de vos programmes. Une application monolithique peut être distribuée par conception : si vous décidez d'en distribuer une partie, il suffit de la prendre et de l'exécuter sur une autre machine.

    Nom : JolieB.png
Affichages : 2887
Taille : 27,5 Ko

    Protocole agnostique

    Jolie est agnostique en termes de protocoles : vos services peuvent échanger des données en utilisant différents protocoles. Le pontage de deux réseaux utilisant des protocoles différents est une question de quelques lignes de code. Si vous avez besoin d'un protocole que Jolie ne prend pas encore en charge, il existe une API pour en développer de nouveaux en Java.

    Nom : Jolie2.PNG
Affichages : 2849
Taille : 25,1 Ko

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    type HelloRequest {
    	name:string
    }
     
    interface HelloInterface {
    requestResponse:
    	hello( HelloRequest )( string )
    }
     
    service HelloService {
    	execution { concurrent }
     
    	inputPort HelloServiceHTTP {
    		location: "socket://localost:9000"
    		protocol: http { format = "json" }
    		interfaces: HelloInterface
    	}
     
    	inputPort HelloServiceSOAP {
    		location: "socket://localost:9001"
    		protocol: soap { 
    			wsdl = "myWsdl.wsdl" 
    			wsdl.port = "MyServiceSOAPPort"
    		}
    		interfaces: HelloInterface
    	}
     
    	inputPort HelloServiceSODEP {
    		location: "socket://localost:9002"
    		protocol: sodep 
    		interfaces: HelloInterface
    	}
     
    	main {
    		// This can now be reached through HTTP/JSON, SOAP, or SODEP (binary)
    		hello( request )( response ) { 
    			response = "Hello " + request.name
    		}
    	}
    }

    Flux de travail structurés

    Jolie est livré avec des primitives natives pour structurer les flux de travail, par exemple en séquences (l'une après l'autre) ou en parallèle (aller en même temps). Cela permet au code de suivre naturellement les exigences, en évitant les variables comptables sujettes aux erreurs pour vérifier ce qui s'est passé jusqu'à présent dans un calcul. Par exemple, le code suivant indique que les opérations publish et edit deviennent disponibles en même temps (|), mais seulement après ( l'invocation de l'opération login.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    login( credentials )() { checkCredentials };
    { publish( x ) | edit( y ) }

    Gestion dynamique des erreurs pour le code parallèle

    La programmation d'un code parallèle fiable est un défi, car les fautes peuvent provoquer des effets secondaires dans les activités parallèles. Jolie est livré avec une sémantique solide pour la gestion des fautes parallèles. Les programmeurs peuvent mettre à jour le comportement des gestionnaires de fautes au moment de l'exécution, en suivant l'exécution des activités grâce à la primitive install

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    include "console.iol"
    include "time.iol"
     
    main
    {
        scope( grandFather )
        {
            install( this => println@Console( "recovering grandFather" )() );
            scope( father )
            {
                install( this => println@Console( "recovering father" )() );
                scope ( son )
                {
                    install( this => println@Console( "recovering son" )() );
                    sleep@Time( 500 )();
                    println@Console( "Son's code block" )()
                }
            }
        }
        |
        throw( a_fault )
    }

    Jolie offre de nombreuses possibilités pour construire des logiciels complexes à partir de services simples. Même l'architecture de déploiement d'un système peut être programmée avec des primitives natives, généralisant les pratiques communes. Tout ce que vous construisez est à nouveau un service que vous pouvez exposer ; ainsi, il peut être réutilisé pour construire à nouveau ! Voici quelques exemples de composition :

    • orchestration : un orchestrateur est un service qui offre des fonctionnalités obtenues en coordonnant d'autres services avec un flux de travail ;
    • agrégation : une généralisation des proxies et des équilibreurs de charge, que vous pouvez utiliser pour composer et exposer les API de services distincts ;
    • redirection : une généralisation des serveurs virtuels, qui masque l'emplacement réel des services aux clients en leur attribuant des noms logiques ;
    • intégration : une généralisation des serveurs d'application, qui exécute d'autres services en tant que composants internes. Elle permet des communications locales rapides et peut même exécuter du code écrit dans d'autres langages que Jolie, comme Java et JavaScript.

    Jolie permet de programmer directement un serveur web qui est juste un service comme tout le reste dans Jolie. Vous n'avez pas besoin d'autres frameworks supplémentaires pour instancier un serveur web. Il est possible d'agréger directement d'autres API de services dans un serveur web Jolie, ainsi les interfaces graphiques web sont complètement indépendantes du système de microservices avec lequel elles interagissent. Le langage supporte nativement JSON, XML, AJAX, GWT, et d'autres technologies.

    Source : Jolie

    Et vous ?

    Quel est votre avis sur la programmation orientée services ?

    Que pensez-vous du langage de programmation Jolie ?

    Quel aspect du langage vous intéresse le plus ?

    Voir aussi :

    La version 3 de Scala, un langage orienté objet et fonctionnel, est disponible, elle apporte une nouvelle conception des abstractions contextuelles et améliore le système de types

    EduTools : la version 2021.4 du plugin de JetBrains pour apprendre et enseigner la programmation est disponible, avec un nouveau référentiel de cours JetBrains Marketplace

    Gradle 7.0 est disponible, il apporte une surveillance du système de fichiers par défaut sur toutes les plateformes prises en charge, y compris les versions récentes de Windows, Linux et MacOS

    TeaVM : un outil pour développer des applications Web rapides et modernes en Java, sans les difficultés d'une pile de développement JavaScript
    Contribuez au club : corrections, suggestions, critiques, ... Contactez le service news et Rédigez des actualités

  2. #2
    Membre régulier
    Homme Profil pro
    Formateur en informatique
    Inscrit en
    septembre 2020
    Messages
    31
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Isère (Rhône Alpes)

    Informations professionnelles :
    Activité : Formateur en informatique
    Secteur : Enseignement

    Informations forums :
    Inscription : septembre 2020
    Messages : 31
    Points : 105
    Points
    105
    Par défaut
    J'ai lu rapidement, mais y a-t-il un autre avantage à par celui de l'abstraction à l'utiliser plutôt que de partir sur des projets Spring Boot ?

Discussions similaires

  1. Beef, un nouveau langage de programmation orienté performance
    Par Stéphane le calme dans le forum Langages de programmation
    Réponses: 9
    Dernier message: 13/03/2020, 20h31
  2. Quel langage de programmation orienté objet et mathématique ?
    Par plouflacig dans le forum Langages de programmation
    Réponses: 7
    Dernier message: 17/12/2017, 03h51
  3. [Bénévole] Projet Open Source (Java) dev's : création d'un langage de programmation
    Par izanagi1995 dans le forum Autres
    Réponses: 0
    Dernier message: 10/01/2014, 10h46
  4. Java Modeling Language
    Par alex_pi dans le forum Langage
    Réponses: 2
    Dernier message: 18/10/2007, 11h59
  5. [Conception] interface java et language c
    Par tthierry dans le forum Général Java
    Réponses: 10
    Dernier message: 10/02/2006, 19h10

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo