12 nouveaux langages de programmation à connaître

Pour certains, l’apprentissage d’un nouveau langage de programmation est un excès qu’il vaut mieux éviter. Pourquoi, oh pourquoi, disent-ils, avons-nous besoin d’un autre langage ?

N’en avons-nous pas déjà assez ?

Les outils existants ne suffisent-ils pas à la tâche ?

Et puis il y a ces chercheurs infatigables qui sautent sur l’occasion d’essayer de nouvelles choses et de tomber sur des joyaux. L’apprentissage est une fin en soi, et ils n’ont pas besoin d’être convaincus pour passer leurs week-ends à construire un jeu de cartes sur console dans ce nouveau langage obscur.

Quel que soit le camp auquel vous appartenez, une chose est incontestable : nous voulons tous consacrer du temps à quelque chose qui aura un bel avenir.

Pour ceux qui appartiennent au camp de l’héritage, leur langage existant préféré a déjà le vent en poupe et continuera d’avoir un bel avenir. Je dois leur rappeler que leur chaîne d’outils de développement préférée, aujourd’hui arrivée à maturité, était autrefois du “kool-aid” que beaucoup refusaient de boire. Il en va de même aujourd’hui : de nouvelles technologies sont ajoutées pour résoudre de nouveaux problèmes ou pour soulager la douleur du développement.

Si quelque chose le fait de manière suffisamment radicale, il y a de fortes chances qu’il continue à gagner des parts de marché et à atteindre le sommet. Lorsque cela se produit, vous ne voulez pas rester en arrière 🙂

Et pour ceux qui aiment courir avec les choses brillantes, un avertissement : s’amuser est essentiel en tant que programmeur, mais nous devons faire attention à ne pas gaspiller notre énergie sans but.

Bien sûr, Brainfuck est un petit langage incroyablement tordu et amusant, mais il est peu probable que vous en tiriez profit en le pratiquant sérieusement. Vous voulez quelque chose de nouveau, de sensé et qui repose sur des bases solides.

Comment ces langues ont-elles été sélectionnées ?

La sélection des langues est une tâche intimidante, en particulier lorsque de nouvelles langues sont envisagées en vue d’avantages futurs en termes d’emploi et de satisfaction. Chaque auteur de langue est fermement convaincu d’avoir construit la langue parfaite possible et d’avoir résolu tous les problèmes auxquels il faut répondre. Alors, comment couper ?

Pour ce billet, je me suis concentré sur quelques paramètres afin de maintenir ma recherche dans des limites raisonnables.

Date de publication

J’ai spécifiquement évité les langages qui sont très, très récents.

Par nouveaux, j’entends les langages qui ont moins de 5-6 ans au moment où j’écris ces lignes, et surtout ceux qui n’ont pas encore atteint la stabilité (la version 1.0, donc). Mais j’espère bien y revenir un jour et écrire sur leur succès 😀

Pour moi, 5 à 12 ans est la période idéale, c’est-à-dire le moment où un langage s’est stabilisé et où des améliorations sont apportées. Bien entendu, il existe des exceptions à cette règle, qui seront prises en compte le cas échéant.

Intérêt marqué de la communauté

Il s’agit d’une évidence, mais elle est souvent ignorée lorsque nous sommes enthousiasmés par quelque chose de nouveau. Pour beaucoup de gens, le soutien d’une grande entreprise suffit à garantir le succès, mais ce n’est pas toujours le cas.

Oui, l’Objective-C d’Apple et maintenant Swift ont prospéré parce que c’étaient les seules options dans un écosystème très contrôlé, mais le D de Facebook et Hack (une version laide d’un langage déjà laid, à mon avis) restent à peine plus que des expériences.

La combinaison idéale serait un langage soutenu par une grande entreprise stable et dont la popularité explose (comme React).

Mais le cœur du problème reste la communauté. Si un langage ne crée pas de buzz et qu’il n’y a pas assez de développeurs pour l’éduquer et le populariser, il ne sortira pas de sa tombe GitHub.

Pour moi, cela exclut les langages matures et fascinants comme Racket et Erlang, car ils sont restés stables sur la courbe de croissance.

Un USP ciblé et bien défini

La troisième chose que je recherche est un objectif clair pour le langage. Par exemple, une meilleure version de PHP qui corrige les problèmes de noms et compile en PHP natif ne me convient pas.

Les avantages sont tout simplement trop faibles pour justifier les craquements si tout le monde essaie de passer à cette version. À cette aune, je ne peux m’empêcher d’écarter des tentatives comme CoffeeScript, et bien d’autres langages similaires compilés en JavaScript.

Honnêtement, je suis obligé de rejeter immédiatement les améliorations syntaxiques. L’histoire a montré que l’utilité l’emporte sur la convivialité lorsqu’il s’agit de langages, alors si tous les nouveaux langages se concentrent sur une expérience plus agréable, j’ai bien peur qu’ils ne fassent pas partie de cette liste.

Une syntaxe claire et cohérente

Oui, je sais. Je viens de dire que la syntaxe n’a pas d’importance. Pour être plus précis, j’ai dit que les “améliorations syntaxiques” n’avaient pas d’importance. Cela dit, la syntaxe reste l’un des facteurs les plus importants de la productivité et de la maintenabilité des programmeurs, et c’est donc un élément qui doit figurer dans mes calculs ici.

La syntaxe s’accompagne de l’idée de cohérence. La dénomination des fonctions, la structuration des modules, etc. sont des éléments clés qu’un langage ne peut pas se permettre d’ignorer. Nous sommes en 2018, pour l’amour de Dieu, et une autre conception de langage semblable à PHP serait une honte pour nous tous. Alors, sans plus attendre, commençons par nos cinq meilleures recommandations.

Julia

Pour les gens du MIT, les langages disponibles pour la science des données étaient au mieux un compromis. Python, malgré sa clarté et sa popularité, manquait de constructions natives pour traiter les objets de données. De plus, en tant que langage interprété, Python était lent pour eux (pas les bibliothèques, bien sûr, car elles sont principalement écrites en C).

Mais ce qui les rebutait le plus, c’était peut-être le modèle de concurrence maladroit et l’absence d’un modèle de calcul parallèle, ce dernier étant un élément essentiel des supercalculateurs.

C’est ainsi qu’est née Julia.

Julia a atteint sa version stable le 29 septembre 2018, à peine quelques jours avant l’écriture de cet article (en parlant de timing !). Voici ce que le site officiel a à dire sur ses capacités :

Julia excelle dans le calcul numérique. Sa syntaxe est parfaite pour les mathématiques, de nombreux types de données numériques sont pris en charge et le parallélisme est disponible dès le départ. Le dispatching multiple de Julia s’adapte naturellement à la définition des types de données numériques et de type tableau.

D’un point de vue syntaxique, Julia peut être considéré comme une combinaison de Python et de C. Oui, c’est probablement la première fois qu’un langage vise ces deux qualités et y parvient.

Pour rester simple, Julia est extrêmement rapide et n’impose pas de typage strict. Voici quelques benchmarks :

Comme vous pouvez le constater, Julia est légèrement moins bon que le C, mais bat Java et Python à plate couture. Et qu’est-ce que Julia a à offrir ?

Voici l’implémentation d’une fonction permettant de calculer l’hypoténuse d’un triangle droit :

Enfin, bien que la majeure partie de l’écosystème Julia soit fortement orientée vers le travail mathématique, je pense qu’elle a un brillant avenir polyvalent.

C’est le premier langage, à ma connaissance, qui dispose d’un support de premier ordre pour le calcul parallèle, il ne sera donc pas surprenant de le voir gagner en popularité dans les domaines du Web et de l’IoT.

Rouille

Si vous avez essayé les nouvelles versions du navigateur Firefox, vous savez qu’enfin, après des années de travail, il semble qu’ils pourraient être en mesure de prendre des parts de marché à Chrome.

Si le navigateur semble léger et rapide et que le rendu l’est tout autant, c’est grâce au langage spécialement développé par Mozilla : Rust.

Dire que Rust est promis à un bel avenir serait mentir ; le langage connaît déjà un succès massif, et si vous n’en avez pas encore entendu parler, c’est que son domaine d’application est pointu, et son objectif effrayant : remplacer le C ! Oui, nous avons enfin un langage qui non seulement est capable de le faire, mais qui le fait déjà.

Pour les personnes frustrées par les problèmes de conception et de gestion de la mémoire du langage C, Rust est une véritable bouffée d’air frais.

Voici à quoi ressemble un programme Rust :

Concis et élégant, à mon avis. Rust suit l’approche de la programmation fonctionnelle, ce qui rend votre code plus composable, et il n’y a pas de hiérarchies orientées objet avec lesquelles se débattre.

Alors, qu’est-ce qui donne à Rust le courage de s’attaquer au C ? C’est le nouveau modèle de mémoire. Plutôt que de s’appuyer sur la vieille danse new()/delete(), Rust introduit l’idée de propriété.

Plutôt que d’allouer et d’accéder directement à la mémoire, les variables Rust “s’empruntent” les unes aux autres, avec des restrictions strictes imposées par le compilateur. Le concept global est trop compliqué pour être expliqué en quelques mots, alors n’hésitez pas à consulter la documentation officielle pour en savoir plus.

Le fait est qu’il en résulte une sécurité de la mémoire à 100 % sans avoir besoin d’un ramasse-miettes, ce qui n’est pas rien.

Rust a pris d’assaut le monde de la programmation système. Il est déjà supporté par certaines plateformes, les navigateurs puissants et les moteurs de rendu remplacent rapidement le code C/C sur les systèmes de production, et il est utilisé pour écrire des systèmes d’exploitation.

Bien sûr, ce n’est pas la tasse de thé de tout le monde de créer un autre navigateur ou pilote de périphérique, mais Rust s’étend déjà à d’autres domaines. Nous avons déjà plusieurs frameworks Web entièrement fonctionnels et ridiculement rapides en Rust, et de plus en plus de bibliothèques d’applications sont en cours de développement.

Honnêtement, si vous êtes intéressé par un avenir passionnant, Rust est le langage parfait, et c ‘ est le moment idéal. Rust est un avion qui a décollé, mais il est encore temps de monter à bord alors qu’il se dirige vers les étoiles !

Apprenez Rust avec Dmitri Nesteruk.

Elixir

Parmi les langages qui mettent l’accent sur le bonheur des développeurs, la première place est définitivement réservée à Ruby. C’est un langage qui se lit comme de la poésie et qui possède suffisamment de raccourcis pour réduire la friction mentale par ordre de grandeur.

Il n’est donc pas étonnant que le framework Rails continue de dominer le développement complet pour les développeurs sérieux et les startups. Mais tout le monde n’était pas satisfait de Rails, en particulier l’un de ses principaux développeurs, José Valim. Je pense que c’est le créateur lui-même qui explique le mieux la genèse de ce langage dans une interview:

C’est une longue histoire, mais je vais essayer de la rendre courte et agréable. En 2010, je travaillais à l’amélioration des performances de Rails sur les systèmes multi-cœurs, car nos machines et nos systèmes de production sont de plus en plus équipés de cœurs. Cependant, l’expérience était assez frustrante car Ruby ne fournit pas d’outil approprié pour résoudre les problèmes de concurrence. C’est alors que j’ai commencé à regarder d’autres technologies et je suis finalement tombé amoureux de la machine virtuelle Erlang.

J’ai commencé à utiliser Erlang de plus en plus et, avec l’expérience, j’ai remarqué qu’il me manquait certaines constructions disponibles dans de nombreux autres langages, y compris des langages fonctionnels. C’est à ce moment-là que j’ai décidé de créer Elixir, dans le but d’apporter des constructions différentes et d’excellents outils au-dessus de la machine virtuelle Erlang.

Et voilà, Elixir est né !

Tout comme Scala améliore le langage Java mais cible la même machine virtuelle (la JVM), Elixir tire parti de la machine virtuelle Erlang, vieille de plusieurs décennies et qui a fait ses preuves.

Une discussion sur Erlang dépasse le cadre de cet article, mais le minimum que vous devez savoir est qu’il s’agit du secret le mieux gardé de l’industrie des télécommunications : si nos réseaux téléphoniques sont beaucoup plus fiables que nos systèmes basés sur le web, c’est grâce à Erlang.

En termes encore plus simples, voici ce que cela signifie. Si vous construisez un système en temps réel comme un chat, Elixir est beaucoup moins gourmand en mémoire vive et beaucoup plus stable que Ruby (ou PHP, Python et Java, d’ailleurs).

Une machine qui utilise Ruby et qui plafonne à 10 000 connexions simultanées peut facilement en gérer 200 000 avec Elixir, tout en conservant suffisamment de mémoire vive pour faire tourner des jeux en 2D !

Sur le plan syntaxique, Elixir copie sans vergogne Ruby, et son principal framework Web, Phoenix, copie sans vergogne Rails. Je dirais que c’est une bonne chose, car avec Laravel, Grails, Masonite, etc., nous arrivons à un point où tous les langages ont des frameworks de type Rails qui peuvent faciliter la transition. Certains pourraient se moquer du “manque d’originalité”, mais au moins je ne me plains pas.

Enfin, Elixir fait partie de ces technologies rafraîchissantes, agréables et sacrément pratiques. Plusieurs ateliers Ruby (et même non-Ruby) sont en train de passer à Elixir, et de grandes entreprises comme Pinterest l’utilisent en production avec des résultats extrêmement satisfaisants.

Beaucoup de gens pensent que Node.js était une tentative improvisée de concurrence et qu’il serait bientôt remplacé par Elixir. Je dois dire que je suis d’accord avec eux 🙂

Kotlin

En 2017, lors de la conférence I/O, Google a lâché une bombe sur la foule qui ne se doutait de rien. La société a officiellement annoncé Kotlin comme langage principal pour le développement Android, envoyant des ondes de choc à travers l’industrie.

Maintenant, que Google ait cherché activement à remplacer Java n’est pas une surprise après avoir été mordu par un procès Oracle ; cependant, l’adoption de Kotlin était quelque peu inattendue, et il y a encore de bonnes chances que Google sorte bientôt sa machine virtuelle. Pour l’instant, cependant, Kotlin jouit d’une grande popularité.

Kotlin a été développé par JetBrains, une société plus connue pour sa suite d’éditeurs de code incroyablement performants. L’un d’entre eux, IntelliJ IDEA, constitue la base d’Android Studio. Les objectifs de conception de Kotlin sont la sécurité, la concision et l’interopérabilité à 100 % avec Java.

Avant tout, le compilateur Kotlin s’efforce d’éliminer les exceptions de type “null-pointer”, si fréquentes dans le monde Java. Il réduit également la verbosité proverbiale de Java, ce qui en soulagera plus d’un.

Voici une magnifique comparaison de code entre Java et Kotlin :

Le code Kotlin est nettement plus court et comporte beaucoup moins de surcharge cognitive.

Mais soyons clairs : il est très peu probable que Kotlin remplace Java, bien qu’il devienne rapidement un favori. Je pense que dans dix ans, les équipes de petite et moyenne taille ne chercheront pas plus loin que Kotlin, tandis que les grands groupes continueront à utiliser Java uniquement pour des raisons d’héritage.

Cela dit, Kotlin a un avenir extrêmement prometteur car il fait tout ce que Java fait, peut fusionner avec du code Java sans que personne ne s’en aperçoive et est beaucoup plus agréable !

TypeScript

Dieu sait que j’ai dû me retenir pour cette place ! Tout en moi criait “Elm ! Elm !”, mais peu importe à quel point ses idées sont révolutionnaires ou sa syntaxe divine, Elm n’est pas encore considéré comme une alternative pour le travail de front-end. 🙁 Quoi qu’il en soit, passons à ce qui est courant : TypeScript.

JavaScript est comme les baies sauvages : laid et détestable, mais vous devez l’avaler si vous voulez survivre dans la jungle du développement front-end. De nombreuses tentatives ont été faites pour le remplacer (et le nouveau standard WebAssembly y parviendra très probablement), mais ce qui a vraiment attiré l’attention de tout le monde, c’est le superset développé par Microsoft.

Il y a de fortes chances que vous ayez entendu parler de TypeScript: Angular a été le premier framework à l’adopter à partir de la version 2, et les gens n’ont pas tardé à en prendre note. C’est parce que TypeScript ajoute des superpouvoirs fantastiques et indispensables au langage de programmation le plus célèbre du monde.

Oui, il est enfin possible d’écrire du code JavaScript natif sans avoir à souffrir et à maudire sa naissance !

Voici les améliorations apportées par TypeScript :

✓ Un typage fort : Enfin, une chaîne de caractères n’est pas un nombre, et un nombre n’est pas un objet, qui n’est pas un tableau vide !

✓ Vérification des types au moment de la compilation : Si votre code se compile correctement, il est plus ou moins garanti qu’il n’est pas affecté par les verrues du runtime JavaScript.

✓ Classes et modules : Oui, les classes sont standard dans ES6, mais elles sont également incluses dans TypeScript, en plus d’un système de modules soigné.

✓ Inférence de type : Pour les types complexes, le type peut être déterminé facilement par le compilateur, ce qui vous évite quelques maux de tête.

✓ Async/await : Les mots-clés et les motifs async/await sont fondamentaux, plus besoin de s’embrouiller avec des promesses et des callbacks !

Espaces de noms, génériques, tuples . . . Je pourrais continuer encore et encore, mais il devrait suffire de dire que TypeScript transforme l’une des pires expériences de développement en l’une des meilleures.

L’impact de TypeScript est indéniable. Il a écarté des tentatives similaires comme Dart de Google (bien qu’il tente un retour avec Flutter, un framework de développement mobile), et a ouvert les yeux des développeurs JS sur les avantages de types plus forts.

En conséquence, des bibliothèques importantes comme React, D3, Vue (même jQuery !) ont maintenant une version TypeScript, et dans les meilleures boutiques de logiciels du monde entier, tout le code JavaScript est écrit en code TypeScript. Les en-têtes TypeScript sont désormais disponibles pour Node.js également (honnêtement, si un nœud peut améliorer son histoire de concurrence et corriger sa mauvaise gestion de la mémoire, il durera éternellement).

Vous serez peut-être surpris d’apprendre que le créateur de Node.js, après avoir publiquement regretté sa création, travaille sur un nouveau runtime (il n’y a pas de site web officiel pour le moment ; juste le repo GitHub) qui a TypeScript comme langage principal.

La meilleure nouvelle ? TypeScript est un petit langage à apprendre qui offre des avantages considérables à l’avenir. Si vous êtes un développeur JavaScript intermédiaire, vous apprendrez suffisamment de TypeScript en deux jours pour porter tout votre code existant !

Elm

Elm est aussi rapide que son nom peut être prononcé et est utilisé pour les applications frontales, les graphiques et les jeux. Il s’agit d’un langage de programmation fonctionnel créé par Evan Czaplicki en 2012.

Elm est réputé pour ne pas avoir d’exceptions d’exécution – c’est là qu’il brille. En tant que langage statiquement typé, le compilateur valide toutes les erreurs au moment de la compilation (wow !) avec des messages amicaux (les messages sont des textes complets et non des codes bizarrement lancés).

Quel soulagement pour les développeurs (de-buggers) ! Vous seriez en mesure d’apprendre à coder dans Elm au fur et à mesure que vous obtenez plus d’erreurs – le compilateur vous dit ce qui ne va pas et vous suggère ce que vous devriez faire pour le corriger !

Elm se targue d’être plus rapide que React et plus fortement typé que même TypeScript. Le code Elm est très organisé et soigné et fera de vous un meilleur développeur.

Comme Elm est basé sur des modules, vous pouvez facilement créer des composants réutilisables. Elm se compile en JavaScript que vous pouvez exécuter sur le navigateur. Ainsi, tout ce dont vous avez besoin pour faire fonctionner Elm est node et npm, et vous pouvez simplement obtenir Elm en utilisant la commande :

npm install -g elm@<version&gt 

Vous pouvez indiquer la version que vous souhaitez installer, par exemple 0.19.1.

Vous pouvez alors vérifier si Elm est correctement installé en utilisant la commande -version. Si vous ne souhaitez pas encore faire toute l’installation et la configuration, allez simplement sur leur site officiel et utilisez l’éditeur en ligne pour jouer.

Alors, jouons un peu !

Si vous n’utilisez pas le compilateur en ligne, vous devrez installer toutes les dépendances pour le programme que nous allons écrire maintenant (c’est assez facile, cependant).

Demandons à un utilisateur de taper son nom dans une zone de texte et d’imprimer ce nom sur la page avec un “hello”.

import Browser
import Html exposing (Html, Attribute, div, input, text)
import Html.Attributes exposant (..)
import Html.Events exposant (onInput)
-- MAIN
principal =
  Browser.sandbox { init = init, update = update, view = view }
-- MODÈLE
type alias Modèle =
  { content : String
  }
init : Modèle
init =
  { content = "" }
-- UPDATE
type Msg
  = Chaîne de changement
update : Msg -> Modèle -> Modèle
update msg model =
  case msg of
    Change newContent -&gt
      { model | content = String.append "Hello..." newContent }
-- VIEW
view : Modèle -> Html Msg
view model =
  div []
    [ input [ placeholder "Tapez votre nom", onInput Change ] []
    , div [] [ text (model.content) ]
    ]

Voici l’écran initial lorsque vous créez le programme :

Tapez un nom, et voici ce que vous obtenez à l’écran :

Bien que ce programme puisse sembler excessif par rapport à son objectif, au fur et à mesure que le programme se complexifie, vous apprécierez la facilité avec laquelle il peut être débogué et maintenu.

Vous pouvez voir une séparation claire entre le modèle, la vue et le contrôleur (mise à jour). De la même manière que nous utilisons les balises HTML, nous pouvons créer des formulaires dans Elm en utilisant les balises div model.

Lors de l’événement “on input” (c’est-à-dire lorsque l’utilisateur saisit un texte), le programme appelle “Change” et imprime le nom de l’utilisateur ainsi que “Hello” à l’aide de la fonction String.append.

Pony

Pony est compilé et suit un modèle d’acteur de calcul conçu pour un comportement asynchrone – c’est-à-dire des applications hautement concurrentes.

Les langages de programmation traditionnels fournissent un “verrou” pour gérer la concurrence, ce qui a un impact sur les performances. Pony n’a pas de verrou, ce qui permet d’éviter les opérations bloquantes ou les scénarios d’impasse. Chaque acteur est mono-fil.

Pony fournit également une sécurité basée sur les capacités, où les utilisateurs doivent utiliser une “capacité de référence” pour accéder à un objet particulier, ce qui garantit une manipulation sûre des données. Par exemple, les capacités décrivent ce que les autres alias se voient refuser plutôt que ce qu’ils sont autorisés à faire.

Des notions telles que la mutabilité et l’isolation sont basées sur ces capacités. Cette caractéristique de capacité de “refus” rend Pony libre de la course aux données.

Pony est sûr, rapide et précis et permet d’économiser du temps de développement, ce qui en fait un bon choix pour les applications bancaires et financières.

Pony garantit la sécurité des types pour la manipulation des données. Il n’a pas d’exceptions – seules les erreurs doivent être gérées pour compiler le code. La raison principale est que Pony est typée statiquement. Vous devez spécifier explicitement le type (comme Java, et contrairement à Python) d’une variable avant de l’utiliser

let name : Chaîne

Comme en Java, vous pouvez créer des constructeurs. Supposons que vous ayez une classe d’employé avec un nom et un âge :

classe Employé
  let name : Chaîne
  let âge : U64
  new create(name' : String) =&gt
    nom = nom'

Les développeurs Java remarqueront peut-être qu’il existe des différences subtiles dans la syntaxe (pas d’accolades, wow !). Il y a également un ”’ à la fin des attributs de la classe. Vous pouvez également créer des fonctions :

fun get_emp_name() : Chaîne => nom

C’estamusant d’écrire des fonctions, n’est-ce pas ?

Maintenant, la partie principale – des acteurs et des promesses.

Les acteurs Pony ont des comportements – similaires aux fonctions – mais seulement asynchrones – ils sont exécutés à un moment donné dans un futur proche mais pas nécessairement immédiatement lorsqu’ils sont appelés. Mais ils “promettent” que les comportements seront exécutés à coup sûr.

acteur Employé
  // l'acteur possède des champs, comme une classe
  let nom : Chaîne
  // et bien sûr, un constructeur
  new create(name' : String) =&gt
    nom = nom'
  // Notez le comportement 'be' au lieu de la fonction fun
  be get_emp_name(promise : Promise[String]) => promise(name)

Les promesses peuvent également être rejetées, si l’acteur ne peut pas répondre à la requête asynchrone envoyée. Vous pouvez créer une promesse :

// Créez une nouvelle promesse

let promise = Promise[String]

Et invoquez le comportement de l’acteur en lui transmettant la promesse à remplir (dans notre cas, l’obtention du nom de l’employé).

employee.emp_get_name(promise)

Pensez-vous que ce code va se compiler ?

Une autre grande caractéristique de Pony est qu’il est sans danger pour la mémoire – pas de NULL ou de dépassement de tampon. Tout code qui pourrait retourner null ne compilera jamais à moins d’être corrigé.

Nous n’avons pas encore dit au programme ce qu’est ’employee’ (notre acteur) :

let employee = Employee("J K Rowling")

Contrairement à tout autre langage de programmation, Pony permet la division par zéro, et le résultat est zéro. Il existe des preuves mathématiques pour toutes les fonctionnalités de Pony.

Pour écrire des programmes Pony, vous devez installer le compilateur Pony. Comme Pony est un langage compilé, vous devez compiler le programme en utilisant ‘ponyc’ avant de l’exécuter.

Une fois le compilateur installé, essayez le programme hello world.

Vyper

Vyper est un langage de programmation de contrats intelligents basé sur Python. Comme Python, il est lisible par l’homme, facile à coder et sécurisé. Vyper compile jusqu’au bytecode de la machine virtuelle Ethereum (EVM). L’EVM identifie l’état de l’Ethereum pour chaque bloc de la blockchain.

Pour comprendre pourquoi Vyper est spécial, il faut comprendre ce que sont les contrats intelligents.

Les contrats intelligents sont des programmes stockés dans une blockchain qui définissent et exécutent un accord entre le vendeur et l’acheteur lorsque les conditions du contrat sont remplies.

Il s’agit de contrats automatisés à exécution automatique qui ne nécessitent pas d’intervention humaine. Cependant, les contrats intelligents sont sujets à des vulnérabilités.

Par exemple, les contrats intelligents peuvent être amenés à libérer de l’éther à des adresses arbitraires ou être tués par des adresses arbitraires, ou ils peuvent ne pas être en mesure de libérer de l’éther. Ces vulnérabilités sont généralement introduites par le biais du code – involontairement ou intentionnellement.

Vyper élimine ce problème en fournissant un code sécurisé, ce qui rend difficile l’introduction d’un code vulnérable ou trompeur. Bien que Vyper soit basé sur Python, il ne suit pas de nombreux paradigmes OOP, comme l’héritage, la surcharge, la récursion, etc. Cela permet d’éviter la complexité du code (avoir plusieurs fichiers, ce qui complique l’audit).

Vyper ne prend pas non plus en charge l’assemblage en ligne, ce qui signifie que les programmes ne peuvent pas effectuer d’actions directement sur l’EVM, évitant ainsi les attaques.

Ces caractéristiques rendent Vyper assez sûr pour l’écriture de code pour les contrats intelligents utilisés dans les blockchains.

Pour vous entraîner à écrire des programmes dans Vyper, vous pouvez utiliser lecompilateur en ligne remix.

Vous pouvez également installer Vyper à l’aide de docker ou de pip (si vous avez Python) en suivant les instructions de la page de documentation de Vyper.

R

R est l’un des langages de programmation les plus populaires pour l’analyse de données et l’apprentissage automatique. Il dispose d’API pour tous les calculs mathématiques, statistiques et scientifiques complexes, les algorithmes d’apprentissage automatique et les représentations visuelles.

R est open source et très populaire pour sa riche interface graphique. Il dispose d’une communauté dynamique et stable et peut facilement s’intégrer à d’autres langages comme le C, le C , etc.

Toutes ces fonctionnalités sont disponibles grâce au CRAN (Comprehensive R Archive Network), qui contient plus de 10000 paquets pour les statistiques, les probabilités, l’analyse de données, l’informatique, les graphiques et bien d’autres choses encore.

Pour découvrir la magie de R, essayons un programme simple pour trouver la moyenne de 11 nombres. Pour trouver la moyenne, nous prenons la somme des nombres et la divisons par le nombre total de valeurs (11 dans notre cas). R dispose d’une fonction appelée “mean” qui effectue tous ces calculs à notre place.

mynums <- c(51, 52, 53, 94, 88, 61, 31, 34, 76, 20, 10)
mean(mynums)

Le résultat est le suivant :

[1] 51.81818

Nous pouvons tracer ces résultats à l’aide de la méthode de tracé :

boxplot(mynums)

Il existe de nombreux packages avancés, tels que ggplot2, dplyr, et bien d’autres, pour afficher des graphiques riches dans R.

Nous pouvons également afficher un histogramme rapide avec les valeurs ci-dessus pour voir la plage dans laquelle les valeurs s’inscrivent.

hist(mynums, breaks = 10, col = "sky blue", main = "Histogramme des marques", xlab = "Height Bin")

Notez que nous avons donné une pause de 10 ; nous pouvons changer ce chiffre pour n’importe quel nombre en fonction des divisions que nous voulons.

La variable ci-dessus, mynum, était un vecteur contenant une liste de nombres. Comme en Python, nous créons un cadre de données en R pour travailler avec plus de dimensions.

Ceci est particulièrement utile pour l’analyse. Par exemple, nous pouvons combiner plusieurs vecteurs, créer un cadre de données et le manipuler en fonction du nombre de variables et du type d’analyse dont nous avons besoin.

Supposons que nous ayons des vecteurs de nom d’employé, de compétence et d’âge. Nous pouvons créer un cadre de données et afficher les données ensemble :

employees = data.frame(Name = c("John", "Mac", "April", "Ron", "Matt"),

                        Age = c(23,28,30,43,31), Skill = c("Java", "Python", "C", "R", "PHP"))

print(employés)

> print(employees)

    Nom Age Compétence

1 Jean 23 Java

2 Mac 28 Python

3 30 avril C 

4 Ron 43 R

5 Matt 31 PHP

Une autre caractéristique intéressante de R est la facilité de manipulation des matrices à l’aide de tableaux. R vous épatera en effectuant des calculs matriciels complexes en un clin d’œil. Tout ce que vous avez à faire est de créer la matrice et de la donner au programme R.

M1 <- matrix(c(1, 2, 1, 2), ncol=2)
M2 print(M1*M2)
     [,1] [,2]
[1,] 3 3
[2,] 8 8

Apache Groovy

Après mûre réflexion et évaluation, j’ai inclus Groovy dans ma liste des meilleurs langages de programmation. Ce langage est comme le beurre sur un délicieux gâteau, apportant une saveur supplémentaire et une amélioration à n’importe quel projet.

L’une des principales raisons pour lesquelles Groovy mérite une place dans cette liste est son large éventail de fonctionnalités, qui ont contribué à sa popularité croissante dans le monde de la technologie. En tant que langage agile et dynamique pour la machine virtuelle Java (JVM), il permet aux développeurs Java d’utiliser des fonctions de programmation modernes avec une courbe d’apprentissage minimale.

Il convient de noter que la JVM est l’abréviation de Java Virtual Machine (Machine Virtuelle Java). La JVM fait partie intégrante de Java et fournit une plateforme permettant d’exécuter le bytecode Java sur n’importe quel appareil. Groovy, construit au-dessus de la JVM, offre un large éventail de fonctionnalités qui améliorent ses performances et en font un choix intéressant pour les développeurs.

En termes simples, il fournit une plateforme pour l’exécution du bytecode Java, ce qui permet d’utiliser Java sur n’importe quel appareil. Du point de vue des performances, Groovy peut vérifier statiquement les types et compiler votre code pour en améliorer la robustesse et les performances.

L’intégration transparente de Groovy avec les classes et les bibliothèques Java existantes le distingue des autres langages de programmation. Il peut également se compiler directement en bytecode Java, ce qui le rend facile à utiliser partout où vous pouvez utiliser Java. Cette caractéristique ajoute à la flexibilité et à la polyvalence de Groovy et en fait un choix de premier ordre pour les développeurs qui cherchent à créer des logiciels efficaces et fiables.

La nature dynamique de Groovy peut rendre la vérification des types problématique et le débogage du code plus difficile, ce qui constitue un inconvénient potentiel. Toutefois, de nombreux programmeurs estiment que la flexibilité et la simplicité de Groovy l’emportent sur les inconvénients potentiels.

En tant que développeur, il est essentiel de reconnaître la valeur unique de Groovy. Pour illustrer ce point, j’aimerais partager un exemple qui montre comment les puissantes fonctionnalités de Groovy peuvent améliorer votre code.

def greeting = "Bonjour, le monde !"
println greeting

// Définissez une liste de nombres
def nombres = [1, 2, 3, 4, 5]

// Utilisez une fermeture pour faire correspondre la liste à ses carrés
def squares = numbers.collect { it * it }

println carrés

Dans cet exemple, nous illustrons la polyvalence et l’expressivité du langage Groovy en définissant une variable de type chaîne de caractères et en l’imprimant sur la console à l’aide de la fonction println.

De plus, nous montrons comment Groovy simplifie des opérations complexes, telles que la transformation d’une liste de nombres à l’aide d’une fermeture pour créer une nouvelle liste contenant les carrés de chaque nombre. Ceci démontre comment Groovy peut améliorer votre productivité en tant que développeur en fournissant une syntaxe concise et lisible pour les tâches de programmation quotidiennes.

Il est donc évident que Groovy mérite l’attention de tous les développeurs.

Le cristal

Après des recherches approfondies, nous n’avons pas pu nous empêcher d’ajouter Crystal à notre liste. Et non, nous ne parlons pas de minéraux ! Crystal est un langage de programmation orienté objet à usage général sorti en 2014. Il a été conçu pour avoir une syntaxe proche de Ruby tout en étant rapide et efficace. Avec son système de types statiques et sa compilation en avance sur le temps, Crystal offre aux développeurs la rapidité du C et la simplicité de Ruby.

Crystal est un langage de programmation relativement nouveau qui gagne en popularité auprès des développeurs en raison de sa vitesse impressionnante et de sa facilité d’utilisation. Il est souvent décrit comme “Fast as C, slick as Ruby”, soulignant sa capacité à fournir des performances rapides comme l’éclair tout en conservant la syntaxe conviviale et la lisibilité de Ruby.

Cependant, Crystal atteint sa vitesse impressionnante en sacrifiant certains des aspects dynamiques de Ruby et en limitant certaines constructions de programmation. Néanmoins, ce compromis a fait de Crystal une option attrayante pour la création d’applications performantes dans un langage plus convivial pour les développeurs.

# Définissez une classe pour une personne avec des attributs de nom et d'âge
classe Personne
  getter nom : Chaîne
  getter age : Int32

  def initialize(@nom : Chaîne, @âge : Int32)
  end
end

# Création d'un tableau d'objets Personne
people = [Person.new("Alice", 25), Person.new("Bob", 30), Person.new("Charlie", 35)]

# Utilisez un bloc pour filtrer le tableau par âge et mettre les noms en majuscules
names = people.select { |person| person.age >= 30 }.map { |person| person.name.upcase }

# Imprimez le tableau de noms en majuscules obtenu
puts names.inspect

Ce code démontre les avantages de Crystal en termes de syntaxe, de performances et de sécurité des types. La syntaxe de Crystal est similaire à celle de Ruby, ce qui la rend facile à lire et à écrire. Cependant, Crystal se compile en code natif, ce qui permet une exécution plus rapide que les langages interprétés comme Ruby.

En outre, Crystal est statiquement typé, ce qui garantit la sécurité des types à la compilation et améliore les performances. Dans cet exemple, le code utilise un bloc pour filtrer un tableau d’objets Personne par âge et mettre les noms en majuscules, ce qui démontre la flexibilité et l’expressivité de la syntaxe de Crystal.

Reason

Reason est un langage de programmation contemporain dont la syntaxe est similaire à celle de JavaScript ou d’autres langages de la famille C, avec le système de types robuste d’OCaml. Grâce à ses fortes capacités de vérification des types, les développeurs peuvent détecter les problèmes plus tôt et écrire un code plus robuste et plus fiable.

L’interface conviviale et la conception simple de Reason en font un choix fantastique pour divers travaux de programmation, quel que soit votre niveau d’expérience en programmation.

Reason et OCaml sont des langages de programmation très polyvalents qui peuvent être utilisés dans différents environnements grâce aux nombreux projets qui les supportent. Une façon de les utiliser est de construire des exécutables natifs qui peuvent être exécutés directement sur votre machine en utilisant le compilateur standard. De plus, plusieurs outils tels que “dune” et “esy” vous aident dans ce processus.

Une autre option consiste à compiler Reason en code JavaScript compatible avec les navigateurs, ce qui peut être réalisé grâce à des projets comme ReScript (anciennement BuckleScript) et Js_of_ocaml. Ces options polyvalentes rendent Reason et OCaml attrayants pour les développeurs de diverses industries.

Reason est un langage de programmation contemporain doté d’une interface conviviale et d’une syntaxe similaire à celle de JavaScript. Sa polyvalence et sa simplicité d’utilisation en font un choix populaire pour les développeurs de divers secteurs.

Conclusion et avis de non-responsabilité

Nous avons tous des préférences différentes, mais les langages ci-dessus valent la peine d’être essayés car ils sont dotés de toutes les nouvelles fonctionnalités et résolvent de nombreux problèmes laissés par les langages précédents.

Elm est parfait pour une séparation plus nette du code et une programmation modulaire. Pony est l’un des meilleurs pour la programmation asynchrone.

Bien que Vyper soit relativement nouveau dans le monde des langages de contrats intelligents, il constitue une alternative prometteuse à Solidity. Vyper est particulièrement performant en ce qui concerne la définition des contrats et la gestion des erreurs. R, quant à lui, est considéré comme l’un des meilleurs langages pour l’analyse et dispose déjà d’une grande communauté.

Certains langages gagnent autant en popularité que ceux présentés dans cet article, mais n’ont pas été inclus dans la liste pour diverses raisons. En voici un aperçu :

• Golang : Déjà établi comme un langage grand public, même s’il n’est pas très populaire. Je pense qu’à ce stade, Golang a plusieurs concurrents qui maintiendront sa part de marché à un niveau bas.
• Swift : Apple a une main de fer sur son écosystème, et Swift est le seul langage disponible. Auparavant, Objective C faisait fureur, tout comme Swift aujourd’hui. Je considère qu’il s’agit d’une tricherie et je refuse donc de l’inclure ici 😀

L’avenir est toujours incertain, et l’une des façons de mener sa carrière est de s’en tenir à ce qui fonctionne déjà et de refuser de se laisser “distraire” Si vous faites cela, Java, PHP, Python, Ruby, etc. sont tous d’excellents langages avec lesquels vous pouvez rester. Cependant, pour certains d’entre nous, la norme ne suffit pas. Ils veulent sortir, explorer et parier gros sur l’avenir. Si vous faites partie de ce dernier camp, l’un de ces cinq langages devrait figurer en tête de votre liste de choses à faire.

Enfin, lorsque vous essayez d’évaluer un langage, ne vous laissez pas submerger par l’effort, car ce n’est pas grand-chose. Si vous connaissez déjà quelques langages de programmation, vous pouvez apprendre n’importe lequel de ces langages en deux mois maximum, à raison de 5 à 6 heures par semaine. En revanche, le bonheur et les bénéfices monétaires qui peuvent être générés à l’avenir seront plusieurs fois supérieurs.

Ensuite, vous pouvez consulter les langages de programmation à utiliser dans le domaine de la science des données.