Elixir : un langage de programmation 100 % web

Auteur(s) :

Le Goff, Vincent (1988-....) Découvrir l'auteur

Résumé

Présentation du langage de programmation Elixir basé sur un autre langage, Erlang, créé par Ericsson en 1987, accessible désormais en open source. Elixir permet ainsi de simplifier le développement de logiciels avec Erlang.

Éditeur(s)
- Éditions Eyrolles
Date
- DL 2023
Langues
- Français
Description matérielle
- 1 vol. (XIV-504 p.) : ill. ; 23 cm
Collections
- Blanche
Sujet(s)
ISBN
- 978-2-416-01175-7
Indice
- 681.25 Autres langages informatiques
Quatrième de couverture
- Elixir
  Un langage de programmation 100 % web
  Il existe beaucoup de langages de programmation et leur nombre augmente d'année en année. Certains disparaissent toutefois, tandis que d'autres parviennent à rester populaires pendant des décennies.
  Alors pourquoi choisir d'apprendre Elixir plutôt qu'un autre ? La raison principale se trouve dans les promesses du langage.
  Il propose de créer un service (site web, jeu vidéo multijoueur, service de streaming, etc.) disponible en permanence, avec une grande réactivité et une garantie de mise à jour sans qu'aucun utilisateur ne soit déconnecté. Il propose également de créer un système facile à distribuer : si votre site web reçoit 100 utilisateurs par jour et que ce nombre augmente, même brutalement, il n'est pas difficile d'ajouter de nouvelles machines qui peuvent aisément gérer la charge supplémentaire, sans interruption du service existant. Elixir assure donc une maintenance efficace.
  Un atout supplémentaire d'Elixir est d'être basé sur un autre langage puissant et stable : Erlang. Créé par Ericsson en 1987, il est désormais accessible en open source et maintient certaines de nos infrastructures les plus critiques, celles qui ne doivent s'interrompre sous aucun prétexte. Mais ne comparons pas Erlang à une baguette magique : les nombreuses possibilités qu'il offre n'épargnent pas un bon investissement de la part du développeur.
  Elixir a été conçu pour simplifier le développement de logiciels avec Erlang. Mais Elixir reste un langage de programmation qui ne fait pas encore partie des plus simples à utiliser.
  Grâce au contenu très riche de cet ouvrage, vous serez très vite en mesure d'utiliser Elixir pour développer au quotidien.
Tables des matières
- - Elixir
  - Un language de programmation 100 % web
  - Vincent Le Goff
  - Éditions Eyrolles
  - Première partie
  - Syntaxe du langage Elixir
  - Chapitre 1
  - Premiers pas avec Elixir 3
  - Pourquoi utiliser Elixir ?3
  - Une disponibilité permanente3
  - La tolérance aux erreurs4
  - La distribution4
  - Une maintenance efficace5
  - Avantages5
  - Inconvénients5
  - Un bref historique du langage6
  - Installation7
  - Sous Linux7
  - Sous Windows8
  - Sous macOS8
  - Une fois l'installation terminée8
  - Une première démonstration9
  - En résumé12
  - Chapitre 2
  - Syntaxe de base 13
  - Un REPL avec Iex13
  - Les premiers types de données14
  - Les nombres14
  - Les atomes16
  - Les binaires16
  - Les variables et les fonctions17
  - Les variables17
  - Les fonctions18
  - En résumé19
  - Chapitre 3
  - Les collections 21
  - Les chaînes de caractères21
  - Brève présentation de l'Unicode21
  - L'UTF-8 à la rescousse22
  - Sous Windows, la prudence s'impose !22
  - Interpolation23
  - Concaténation24
  - Les bitstrings25
  - Les listes de caractères (charlist)26
  - Les tuples et les listes26
  - Les tuples26
  - Les listes28
  - Une liste en mémoire29
  - Une liste de mots-clés30
  - Les fourchettes31
  - Les maps32
  - Syntaxe de base et manipulation32
  - Les maps d'atomes34
  - En résumé36
  - Chapitre 4
  - Le conditionnel 37
  - L'opérateur =37
  - La correspondance37
  - L'affectation38
  - L'extraction d'un tuple38
  - L'extraction d'une liste39
  - L'extraction d'une map40
  - Plusieurs correspondances40
  - L'épingle41
  - case42
  - cond et if44
  - cond45
  - Les connecteurs47
  - if et unless48
  - En résumé50
  - Chapitre 5
  - Introduction au fonctionnel 51
  - Fonctions définies en modules51
  - Fonction et paramètres51
  - Fonction et données52
  - Conservation des données53
  - Fonction et modules54
  - Créer une fonction54
  - Les fonctions à multiples clauses57
  - Les fonctions anonymes61
  - La syntaxe61
  - Chaîner des fonctions entre elles63
  - L'opérateur de chaînage63
  - Le mot-clé with66
  - En résumé70
  - Chapitre 6
  - Récursivité et itération 71
  - La récursivité71
  - Un premier exemple71
  - La nature récursive des listes73
  - Des fonctions définies75
  - Enum.map76
  - Enum.each77
  - Enum.filter77
  - Enum.reduce78
  - Plus de lisibilité grâce aux compréhensions80
  - Chaînage des opérations82
  - Autres opérations83
  - La capture et l'appel de fonctions capturées83
  - Le point pour appeler une fonction84
  - L'esperluette pour capturer une fonction85
  - La récursivité n'est pas gratuite87
  - Les opérations en chaîne87
  - Le dernier élément récursif89
  - En résumé92
  - Chapitre 7
  - Les modules 93
  - Les modules et les fonctions93
  - Un fichier pour un module94
  - Compilation et exécution94
  - Gestion de projets avec mix95
  - Avantages de mix99
  - Les modules et la compilation100
  - Hiérarchie des modules100
  - Syntaxes avancées des fonctions101
  - L'arity 101
  - Les fonctions sur une ligne 102
  - Les garde-fous 103
  - Les paramètres par défaut. 106
  - Les fonctions privées 108
  - Les attributs du module109
  - Syntaxe des attributs109
  - Récupérer la valeur de l'attribut111
  - Les structures111
  - Définition et syntaxe112
  - Un peu de contexte113
  - En résumé116
  - Chapitre 8
  - De bonnes habitudes à prendre 117
  - La documentation de notre projet117
  - Utilité de la documentation118
  - Documentation du code119
  - Documentation des modules119
  - Documentation des fonctions120
  - Les spécifications de types122
  - L'intérêt des spécifications de types122
  - Syntaxe simple123
  - Les types courants123
  - Les tests du projet126
  - Pourquoi tester ?127
  - Les types de tests127
  - Le test dans la documentation128
  - Un projet de jeu de cartes 129
  - Les scripts de tests134
  - Un petit exercice 138
  - Un problème avec doctest 140
  - Les scripts de tests 140
  - Conclusion143
  - En résumé144
  - Chapitre 9
  - Introduction à l'abstraction 145
  - Le polymorphisme implicite145
  - Le polymorphisme de données146
  - Le polymorphisme de comportement147
  - Les protocoles149
  - String.Chars150
  - Inspect152
  - Enumerable153
  - La taille d'une pile de cartes 153
  - Un élément dans une pile de cartes 155
  - Le support du parcours de la collection 156
  - Implémentation du protocole Inspect pour la structure Pile157
  - Quelques exercices157
  - new(52) 158
  - Pile.mélanger 159
  - Pile.retirer 161
  - Pile, transférer 163
  - Pile.fusionner. 164
  - Les comportements165
  - Les règles du jeu166
  - Syntaxe du comportement166
  - Implémentation de nos règles génériques169
  - Implémentation de règles spécifiques171
  - Structure du jeu 171
  - Jeu.Huit.titre 173
  - Jeu.Huit.new 173
  - Jeu.Huit.ajouterJoueur ? 174
  - Jeu.Huit.ajouterJoueur 175
  - Jeu.Huit.jouer ? 177
  - Jeu.Huit.jouer 180
  - Jeu.Huit.jouerjcarte 183
  - Jeu.Huit.valider_tour 183
  - Jeu.Huit.joueur_suivant 184
  - Jeu.Huit.changer_sens 184
  - Jeu.Huit.piocher. 184
  - L'intérêt du comportement185
  - En résumé186
  - Deuxième partie
  - Du processus à la distribution187
  - Chapitre 10
  - Les processus en Elxir 189
  - La notion de processus189
  - Une erreur peut tout gâcher189
  - Exécution séquentielle190
  - La théorie du processus192
  - Création de processus192
  - Création indépendante avec spawn192
  - Création de processus liés avec spawn_link194
  - La communication entre processus195
  - L'envoi de messages195
  - Réception de messages196
  - Communication de résultats197
  - Fonctions clients et fonctions internes200
  - État et processus201
  - Un processus longue durée201
  - Un processus serveur203
  - En résumé217
  - Chapitre 11
  - L'état, l'agent et le serveur générique 219
  - L'agent et l'état219
  - Une abstraction, un comportement220
  - La notion d'état partagé220
  - Un agent indépendant221
  - Un agent placé dans un module223
  - Le serveur générique225
  - Fonctionnalités225
  - Opérations synchrones et asynchrones226
  - La calculette lente dans un serveur générique229
  - Un serveur par jeu de cartes235
  - Le serveur communique en envoyant des messages239
  - Des fonctions supplémentaires240
  - Conclusion247
  - En résumé247
  - Chapitre 12
  - Découverte des processus 249
  - Le nom des processus249
  - Atomes et alias250
  - Limites des atomes 250
  - Les modules et les atomes 252
  - Les registres de processus255
  - Un registre indépendant255
  - Un registre dans un module257
  - Les groupes de processus257
  - D'autres méthodes de découverte259
  - En résumé260
  - Chapitre 13
  - La supervision des processus 261
  - Le superviseur261
  - Les liens262
  - Les moniteurs265
  - Le superviseur et sa stratégie270
  - La description des processus supervisés274
  - Les stratégies du superviseur276
  - La supervision dynamique277
  - La supervision et la découverte des processus279
  - La supervision et l'état des processus285
  - L'application et son arbre de supervision286
  - L'application286
  - L'arbre de supervision290
  - En résumé291
  - Chapitre 14
  - Les applications 293
  - La structure d'une application293
  - Projets et applications293
  - Les environnements de développement297
  - Sous Linux ou macOS 298
  - Sous Windows avec cmd. exe 298
  - Sous Windows avec Power Shell 298
  - La configuration299
  - La configuration de Logger 300
  - Les étapes de configuration 302
  - Les dépendances303
  - JSON et Jason303
  - Les dépendances dans mix.exs303
  - Téléchargement de dépendances304
  - Utilité des dépendances306
  - L'application sous parapluie306
  - Création d'un projet parapluie307
  - Principales différences de l'application sous parapluie309
  - En résumé312
  - Chapitre 15
  - Le système distribué 313
  - La notion de node313
  - La connexion en local314
  - La connexion de machines distantes318
  - Installation d'Elixir 319
  - Obtention des adresses IP 319
  - Connexion d'Elixir entre machines 320
  - Tout fonctionne... enfin !323
  - Quelques questions fréquentes324
  - La distribution et ses erreurs325
  - Comparaison des systèmes local et distribué326
  - Les partitions, le pire scénario ?327
  - Le théorème CAP329
  - Des structures à la rescousse330
  - La distribution dynamique 330
  - La distribution par chemin 331
  - Beaucoup de réflexion 334
  - La découverte des processus distribués334
  - Les groupes de processus334
  - L'enregistrement global du processus335
  - Conclusion339
  - En résumé339
  - Troisième partie
  - La distribution en pratique341
  - Chapitre 16
  - Préparation des interfaces 343
  - Une interface, des interfaces343
  - Des choix d'architecture344
  - Un point d'entrée pour l'application carte346
  - Mode de fonctionnement du point d'entrée347
  - Création d'une nouvelle partie350
  - Choix de l'instance la moins sollicitée 351
  - Choix d'un identifiant unique de partie 354
  - Trouver le PID d'une partie sur n'importe quelle instance359
  - Consulter la liste des parties360
  - Ajouter un joueur et jouer362
  - Petit bonus369
  - Code complet du module Jeu370
  - La découverte des instances avec libeluster374
  - Installation de libcluster375
  - Configuration de libcluster376
  - Distribué ou non ? C'est l'heure de trancher !378
  - Chapitre 17
  - Une interface en console 381
  - Création de l'application console381
  - Configurer l'application console382
  - Vérifier que l'application fonctionne383
  - Implémenter les fonctionnalités de l'application384
  - Lire les entrées clavier385
  - Structure du code386
  - L'interface et le clavier386
  - Les écrans, responsables de l'expérience390
  - Cycles de vie des écrans 392
  - Entrer le nom du joueur 398
  - Lister les parties 401
  - Jouer dans une partie 405
  - Tenir compte des demandes d'actualisation 409
  - Tester l'interface409
  - Des améliorations à notre jeu412
  - Chapitre 18
  - Une interface web via Phoenix(1/2) 415
  - Phoenix, introduction et installation415
  - Installer Phoenix416
  - Créer notre application web418
  - Lancer le serveur web420
  - Configurer l'application422
  - Le mécanisme MVC appliqué à Phoenix425
  - De l'URL à la requête425
  - De la requête au contrôleur426
  - Du contrôleur à la vue et au template430
  - Du template à la page complète432
  - Et le M ?433
  - Modifier et créer la page433
  - Modifier la page d'accueil434
  - Créer une nouvelle page434
  - Ajouter une route 435
  - Le contrôleur 435
  - Le template 436
  - Où sont les parties ? 436
  - Transmettre une variable du contrôleur à la vue 437
  - Entrer le nom du joueur. 440
  - En conclusion442
  - Chapitre 19
  - Une interface web Phoenix (2/2) 443
  - LiveView, la beauté du temps réel443
  - Fonctionnement de LiveView444
  - Avantages et inconvénients de LiveView444
  - Une simple démonstration avec LiveView445
  - Une route comme les autres... ou presque 447
  - Une information qui s'actualise 448
  - Les évènements dans les vues dynamiques 452
  - Les composants dynamiques (LiveComponent)453
  - Un premier exemple de composants dynamiques453
  - Créer le composant dynamique 454
  - Actualiser les compteurs en temps réel 457
  - Mettre en pause un compteur 459
  - Le partage de données 461
  - LiveView et le jeu de cartes462
  - La session et son espace de stockage462
  - Créer la route463
  - Créer la vue dynamique464
  - Ajouter des liens dans les templates465
  - Implémenter la vue dynamique466
  - Le composant dynamique 467
  - La vue dynamique 468
  - Création d'une nouvelle partie470
  - Conclusion471
  - Chapitre 20
  - Une interface en réseau 473
  - Le réseau et la communication473
  - Une communication par protocoles474
  - Je communique, j'encode, je décode474
  - TCP (Transmission Control Protocol)476
  - gen_tcp et le réseau en Elixir476
  - Créer et configurer l'interface477
  - Architecture de l'application et ses processus478
  - La tâche du serveur478
  - Le client482
  - La tâche du messager 483
  - Les étapes de connexion485
  - L'abstraction Reseau.Etape 486
  - Entrer le nom du joueur 489
  - Afficher la liste des parties 491
  - Jouer à un jeu 494
  - Modifier le client496
  - Conclusion500
  - Index 501
Origine de la notice:
- BPI