Apprendre Erlang vs apprendre node.js
Je vois beaucoup de conneries en ligne sur la façon dont Erlang botte le cul de node.js dans à peu près toutes les catégories imaginables. J'aimerais donc apprendre Erlang et essayer, mais voici le problème. Je trouve que j'ai beaucoup plus de mal à récupérer Erlang que je ne l'ai fait avec node.js. Avec node.js, je pouvais choisir un projet relativement complexe, et en une journée, j'avais quelque chose qui fonctionnait. Avec Erlang, je me heurte à des obstacles, et je ne vais pas aussi vite.
Alors .. pour ceux qui ont plus d'expérience, Erlang est-il compliqué à apprendre, ou ai-je juste oublié quelque chose? Node.js n'est peut-être pas parfait, mais je semble pouvoir faire avancer les choses.
Tout d'abord, je suis d'accord avec la réponse de JUSTE MON AVIS correct concernant l'apprentissage d'Erlang. C'est un langage principalement fonctionnel (bien que la concurrence joue un grand rôle), et toutes ses fonctionnalités ont été ajoutées pour aller vers la tolérance aux pannes et la robustesse, ce qui n'est pas exactement les mêmes objectifs de conception que Javascript en premier lieu.
Deuxièmement, quitter Node.js pour entrer dans Erlang est un peu déplacé. Node.js est un serveur/framework unique qui fait son chemin pour tout faire de manière événementielle à l'aide de rappels. Erlang a son propre framework (OTP), mais ce n'est pas du tout au même niveau.
Si vous prévoyez d'apprendre Erlang, je suggère mon entrée de blog ne lettre ouverte au débutant Erlang (ou spectateur) comme lecture d'introduction avant de plonger dans des tutoriels.
La seule chose dans laquelle vous pouvez comparer Erlang et Node.js, en termes de modèles et d'utilisation, est de savoir comment ils sont pilotés par les événements. Cependant, il y a deux grandes différences majeures ici. Le modèle de Node.js est basé sur des rappels liés aux événements. Erlang est basé sur des files d'attente de messages et des réceptions sélectives. Quelles sont les implications là-dedans?
Tout d'abord, si vous faites les choses en fonction du rappel, la seule façon de transporter l'état est de l'avoir global ou de passer à une programmation de style passant par la continuation. Deuxièmement, vous devez vous occuper de la matrice d'événements complète. Un exemple de ceci est que si nous imaginons une machine à états finis très simple: un sémaphore mutex, piloté par les événements.
Le sémaphore mutex a deux états: verrouillé et libre. Chaque fois qu'une unité de calcul donnée (travailleur, processus, fonction ou thread) veut accéder au mutex, elle doit déclencher un événement qui lui dit "Je suis intéressé". Vous devez maintenant vous occuper des types d'événements suivants:
- Le mutex est gratuit et vous demandez à obtenir le verrou
- Le mutex est verrouillé par quelqu'un d'autre et vous souhaitez obtenir le verrou
- Le mutex est verrouillé par vous-même et vous souhaitez libérer le mutex
Ensuite, vous devez prendre en compte d'autres événements, tels que la temporisation pour éviter les blocages:
- Le mutex a été verrouillé et vous avez attendu trop longtemps, une minuterie pour arrêter les feux
- Le mutex a été verrouillé et vous avez attendu trop longtemps, vous avez obtenu le verrou, puis la temporisation s'est déclenchée
Ensuite, vous avez également les événements hors limite:
- vous venez de verrouiller le mutex alors qu'un travailleur s'attendait à ce qu'il soit libre. Maintenant, la requête de ce travailleur doit être mise en file d'attente afin que lorsqu'elle est gratuite, elle soit traitée en retour
- Vous devez rendre tout le travail asynchrone
La matrice d'événements se complexifie très rapidement. Notre FSM n'a ici que 2 états. Dans le cas d'Erlang (ou de toute langue avec des réceptions sélectives et asynchrones avec des événements potentiellement synchrones), vous devez vous soucier de quelques cas:
- Le mutex est gratuit et vous demandez à obtenir le verrou
- Le mutex est verrouillé par quelqu'un d'autre et vous souhaitez obtenir le verrou
- Le mutex est verrouillé par vous-même et vous souhaitez libérer le mutex
Et c'est tout. Les temporisateurs sont traités dans les mêmes cas que les réceptions sont effectuées, et pour tout ce qui a à voir avec `` attendre qu'il soit gratuit '', les messages sont automatiquement mis en file d'attente: le travailleur n'a qu'à attendre une réponse. Le modèle est beaucoup, beaucoup plus simple dans ces cas.
Cela signifie que dans les cas généraux, CPS et les modèles basés sur les rappels tels que celui dans node.js vous demandent soit d'être très intelligent dans la façon dont vous gérez les événements, soit de vous occuper d'une matrice d'événements complexe dans son intégralité, car vous devez être rappelé pour chaque cas sans conséquence résultant de problèmes de synchronisation étranges et de changements d'état.
Les réceptions sélectives vous permettent généralement de vous concentrer uniquement sur un sous-groupe de tous les événements potentiels et de raisonner avec beaucoup plus de facilité sur les événements dans ce cas. Notez qu'Erlang a un comportement (modèle de conception/implémentation du framework) de quelque chose appelé gen_event. L'implémentation gen_event vous permet d'avoir un mécanisme très similaire à ce qui est utilisé dans node.js si c'est ce que vous voulez.
Il y aura d'autres points qui les différencieront; Erlang a une planification préemptive tandis que node.js la rend coopérative, Erlang est plus apte à certaines applications à très grande échelle (distribution et tout), mais Node.js et sa communauté sont généralement plus aptes au Web et connaissent la dernière tendance du Web. Il s'agit de choisir le meilleur outil, et cela dépendra de votre expérience, de votre type de problème et de vos préférences. Dans mon cas, le modèle d'Erlang correspond très bien à ma façon de penser. Ce n'est pas forcément le cas pour tout le monde.
J'espère que cela t'aides.
Erlang n'est pas compliqué à apprendre, c'est juste étranger à l'état d'esprit que la constante Chambers (99,44%) des codeurs a appris comme le fonctionnement de la programmation. Le problème auquel vous êtes confronté n'est probablement qu'une désorientation conceptuelle plutôt qu'une complexité réelle.
Voici quelques-unes des fonctionnalités extraterrestres d'Erlang qui vont mordre un programmeur typique:
- Erlang est un langage de programmation (principalement) fonctionnel. La plupart des langages de programmation courants sont presque impérativement militants.
- Le modèle de concurrence d'Erlang est le modèle Acteur. La plupart des langages de programmation courants utilisent soit un thread basé sur des verrous, soit une forme d'approche basée sur un "réacteur" de la concurrence. (Je pense que Node.js est le dernier, mais ne m'appelez pas dessus - je n'ai aucun intérêt pour JavaScript de n'importe quel côté de la relation client/serveur.)
- Erlang a une approche de "laisser tomber" pour le codage avec de puissantes fonctionnalités d'exécution disponibles pour détecter ces plantages, les diagnostiquer et les corriger à chaud pendant que le système fonctionne. Les langages de programmation les plus courants adoptent un style de programmation fortement défensif.
- Erlang est presque, mais pas tout à fait, inextricablement associé à une grande bibliothèque d'architectures couramment utilisées pour des serveurs fiables et stables (OTP). (Il y a une raison pour laquelle Erlang est généralement appelé Erlang/OTP.) De plus, cette bibliothèque est construite sur les fonctionnalités étrangères mentionnées précédemment et est donc opaque pour les nouveaux arrivants. La plupart des langages de programmation ont moins de bibliothèques globales (malgré Java EE) avec lesquelles travailler et lesdites bibliothèques sont, naturellement, construites sur des concepts qui sont plus familiers à la plupart des programmeurs.
Ainsi, apprendre Erlang va être plus un défi pour la plupart des programmeurs que d'apprendre Node.js - surtout si le programmeur est déjà familier avec JavaScript. En fin de compte, cependant, une fois que vous aurez franchi la barrière conceptuelle, je soumets que le codage Erlang va être moins complexe que le codage Node.js équivalent. C'est pour plusieurs raisons:
- Le modèle de concurrence d'Erlang rend le flux logique beaucoup plus clair que la concurrence de style "réacteur" typique et rend la concurrence beaucoup plus stable et correcte que la concurrence basée sur un verrou typique. Ce n'est presque pas un problème pour un programmeur Erlang de supprimer littéralement des milliers de processus dans un programme typique tout en déposant des milliers de threads dans, disons, Java serait un cauchemar de discorde (sans parler de la mémoire et des frais généraux du processeur impliqués) et l'équivalent de maintenir des milliers d'états séparés dans une configuration basée sur un "réacteur" serait un cauchemar à lire.
- Étant un langage (principalement-) fonctionnel, Erlang est vraiment une configuration "ce que vous voyez est ce que vous obtenez". Les variables, une fois définies, ne changent pas. Déjà. Il n'y a pas de OOP "action fantasmagorique à distance" pour vous dérouter: tout ce avec quoi vous travaillez est explicitement présenté devant vous. Il n'y a pas de variables héritées de X et pas de variables de classe de Y et pas de variables globales de Z pour vous préoccuper. (Ce dernier point n'est pas vrai à 100%, mais c'est vrai dans un nombre si écrasant de cas qu'il est assez bon pour votre phase d'apprentissage.)
- Les puissantes fonctionnalités d'Erlang pour gérer les erreurs signifient que vous encombrez votre code avec une programmation moins défensive, gardant ainsi la logique plus claire et gardant le code petit.
- La bibliothèque OTP, une fois que vous l'avez trouvée, est une pile incroyablement puissante de code commun qui maintient votre application entière régulière et couvre de nombreux problèmes et cas d'utilisation de serveurs à longue durée de vie auxquels vous ne penserez probablement pas avant qu'il ne soit trop tard. La bibliothèque OTP elle-même est, IM (ns) HO une raison suffisante pour apprendre Erlang.
Continuez à traîner à Erlang si vous le pouvez, et si vous ne l'avez pas encore fait, allez visiter Learn You Some Erlang for Great Good pour une introduction douce et (surtout-) amusante aux concepts d'Erlang.
Il y a quelques différences importantes entre Erlang et Node
Le premier est que le nœud est Javascript, ce qui signifie que c'est un langage très commun qui partage beaucoup de traits avec des langues que plus de gens connaissent, il est donc beaucoup plus facile de se mettre en route. Erlang a une syntaxe souvent étrange et inconnue pour la plupart, et bien que comme une langue est beaucoup plus simple que javascript, il faut un peu plus de temps pour s'y habituer en raison de son caractère unique
La seconde est qu'Erlang a un modèle de concurrence partagé très particulier, il vous oblige à penser différemment pour résoudre les problèmes, ce qui est une bonne chose (TM)
Le dernier point important est qu'Erlang a été développé par une société commerciale et open source après coup, il y a seulement 2 ans environ, afin que les gens puissent réellement voir les commits individuels dans le contrôle de source et même maintenant, je ne pense pas que tous les développeurs erlang aient déménagé au dépôt github public pour leur développement. node.js a été construit à l'intérieur de la communauté depuis le début, cela signifie que son support communautaire est bien meilleur, il y a déjà beaucoup plus de bibliothèques pour node, plus de documentation de communauté, plus d'exemples en direct, un gestionnaire de paquet omniprésent, etc. Erlang rattrape son retard à cet égard, mais c'est encore une rampe beaucoup plus grande pour se lever.
Node vous permettra de programmer des choses amusantes assez rapidement et relativement sans douleur, il a toujours des difficultés croissantes en ce qui concerne les grandes applications que erlang a résolues depuis longtemps. Erlang changera la façon dont vous programmez et (imo) fera de vous un meilleur programmeur, mais cela ne vous facilitera pas la vie au début. Les deux sont amusants de différentes manières.