Comment installer F # et configurer un environnement de programmation local sur Ubuntu 18.04

https://fsharp.org [F #] est un langage de programmation open source développé initialement par Microsoft Research pour étendre .NET, l’ensemble d’outils, de bibliothèques et de langages Microsoft à applications et services. Outre sa syntaxe remarquablement concise, F # prend en charge plusieurs paradigms, ce qui signifie qu’il peut effectuer différents types de structuration de code, bien qu’il ait été conçu principalement pour tirer parti de l’approche de programmation fonctionnelle. .

L’adoption d’un paradigm spécifique, ou d’un style de code, détermine la façon dont nous allons penser et organiser notre résolution de problèmes de programmation. Avec une approche approximative, le modèle de conception utilisé dans des langages tels que C++ ou Java, a Le développeur décrit, étape par étape, comment l’ordinateur doit accomplir une tâche. Il s’agit d’écrire une séquence d’instructions qui modifieront les états de la mémoire lors de l’exécution du programme. Cela fonctionne bien jusqu’à ce que nous rencontrons des situations irrégulières. Considérons un objet _shared par exemple, utilisé simultanément par plusieurs applications. Nous voudrons peut-être lire sa valeur en même temps qu’un autre composant la modifie. Ce sont des "actions simultanées" sur un emplacement mémoire qui peuvent produire une incohérence dans les données et un comportement indéfini.

Dans functional code design, nous évitons ce type de problème en minimisant l’utilisation de mutable states, ou stipule que peut changer après que nous les fassions. Fonction est le mot clé ici, faisant référence à des transformations mathématiques sur certaines informations fournies sous forme d’arguments. Un code fonctionnel exprime le programme en composant la solution sous la forme d’un ensemble de fonctions à exécuter. En règle générale, nous construisons des couches de logique en utilisant des fonctions qui peuvent renvoyer une autre fonction ou en prendre d’autres comme entrées.

La programmation fonctionnelle avec F # apporte de nombreux avantages:

Dans la mesure où F # est multiplate-forme, il est essentiel de conserver un comportement de modèle d’exécution similaire sous différents systèmes d’exploitation. .NET y parvient au moyen d’une exécution. Un système runtime est un logiciel qui orchestre l’exécution d’un programme écrit avec un langage de programmation spécifique, gérant l’interface avec le système d’exploitation et la gestion de la mémoire, entre autres.

Il existe actuellement deux implémentations d’exécution .NET disponibles sous Linux: .NET Core et https://www.mono-project.com [Mono] . Historiquement, .NET ne fonctionnait que sous Windows. À cette époque, on pouvait avoir recours au projet de communauté Mono pour exécuter des applications .NET sur d’autres plates-formes telles que Linux et macOS. Microsoft a ensuite lancé .NET Core, un sous-ensemble plus rapide et modulaire du framework .NET d’origine, pour cibler plusieurs plates-formes.

Au moment de la publication de ce didacticiel, ils peuvent tous deux être utilisés pour créer des applications Web ou des utilitaires de ligne de commande. Cela dit, .NET Core ne fournit pas de modèles permettant de créer des applications de bureau à interface graphique sous Linux et macOS, alors que Mono est le seul à prendre en charge les plates-formes de jeux et de mobiles. Il est important de connaître ces différences, car le runtime que vous choisissez déterminera les programmes que vous allez construire. Vous pouvez également choisir d’installer .NET Core et Mono afin de prendre en compte tous les cas d’utilisation et de créer une pile plus productive.

Dans ce tutoriel, vous allez configurer un environnement de programmation F # sur Ubuntu 18.04 en utilisant à la fois les environnements d’exécution .NET Core et Mono. Vous écrirez ensuite des exemples de code pour tester et réviser les méthodes de construction et de compilation.

Pour compléter ce didacticiel, vous devez avoir une connaissance de base de la ligne de commande et d’un ordinateur exécutant Ubuntu 18.04 avec un https://www.digitalocean.com/community/tutorials/initial -server-setup-with-ubuntu-18-04 # step-2-% E2% 80% 94-créer-un-nouvel-utilisateur [utilisateur non root avec privilèges sudo].

Microsoft fournit le *.NET Kit de développement logiciel (SDK) * pour les développeurs F #. Un kit de développement logiciel est un ensemble d’outils de programmation permettant aux programmeurs de produire des applications spécialisées et de les adapter à divers systèmes d’exploitation. Il inclut généralement un éditeur de texte, une prise en charge des langages, un runtime et un compilateur, entre autres composants. Dans cette étape, vous allez installer ce SDK. Mais d’abord, vous allez enregistrer le référentiel Microsoft et récupérer des dépendances.

L’installation et la configuration s’effectuent à l’aide de la ligne de commande, qui est un moyen non graphique d’interagir avec votre ordinateur. Autrement dit, au lieu de cliquer sur des boutons, vous saisissez du texte et recevez également les commentaires de votre ordinateur.

La ligne de commande, également appelée shell ou terminal, permet de modifier et d’automatiser bon nombre des tâches que vous effectuez quotidiennement sur un ordinateur. Elle constitue un outil essentiel pour les développeurs de logiciels. Il existe de nombreuses commandes de terminal à apprendre qui peuvent vous permettre de faire des choses plus puissantes. Pour plus d’informations sur la ligne de commande, consultez le tutoriel Introduction to the Linux Terminal.

Sur Ubuntu 18.04, vous pouvez trouver l’application Terminal en cliquant sur l’icône Ubuntu dans le coin supérieur gauche de votre écran et en tapant + terminal + dans la barre de recherche. Cliquez sur l’icône de l’application Terminal pour l’ouvrir. Vous pouvez également appuyer simultanément sur les touches + CTRL,` + ALT` et + T + du clavier pour ouvrir automatiquement l’application Terminal.

image: https: //assets.digitalocean.com/articles/eng_python/UbuntuDebianSetUp/UbuntuSetUp.png [Terminal Ubuntu]

Une fois le terminal ouvert, utilisez la commande + wget + pour télécharger un package contenant les fichiers requis, les configurations du référentiel Microsoft et une clé pour la communication entre serveurs.

Ajoutez maintenant le référentiel Microsoft et installez les packages sur votre système à l’aide de l’instruction + dpkg -i +.

Activez ensuite le référentiel Universe, qui, sur Ubuntu, est une archive de logiciels gérée par la communauté, libre et ouverte. Cela vous donnera accès à + ​​apt-transport-https +, une dépendance permettant d’activer le transport APT du gestionnaire de paquets Ubuntu via HTTPS.

Ensuite, mettez à jour les téléchargements disponibles:

Enfin, installez la current version du SDK .NET. Ce tutoriel utilisera la version 2.2:

Maintenant que le SDK .NET est installé, un moyen rapide de vérifier si tout va bien est d’essayer l’interface de ligne de commande .NET Core, qui sera disponible dans le shell une fois que le SDK sera téléchargé et installé. Affichez des informations sur votre configuration .NET en tapant ceci dans votre terminal:

Lorsque vous exécutez une commande + dotnet + pour la première fois, une section de texte s’affiche, comme indiqué ci-dessous:

Cette notification concerne les données collectées et explique que certaines commandes de la CLI .NET enverront des informations d’utilisation à Microsoft. Vous désactiverez ceci dans un instant. pour l’instant, regardez le résultat de + dotnet --info +.

Après un bref moment, le terminal affichera des informations sur votre installation .NET:

Selon la version du SDK, la sortie peut être légèrement différente, mais cela confirme que .NET Core est prêt à être utilisé.

Comme mentionné précédemment, la fonctionnalité de télémétrie permet à certaines commandes .NET CLI d’envoyer des informations d’utilisation à Microsoft. Elle est activée par défaut et peut être désactivée en définissant la variable d’environnement + DOTNET \ _CLI \ _TELEMETRY_OPTOUT + sur + 1 +. Pour ce faire, ajoutez une nouvelle ligne à votre fichier de personnalisation de l’environnement + .profile + en l’ouvrant dans votre éditeur de texte. Pour ce tutoriel, nous allons utiliser + nano +:

Ajoutez la ligne suivante à la fin de + .profile +:

~ / .profile

Quittez + nano + en appuyant sur les touches + CTRL + et + X +. Lorsque vous êtes invité à enregistrer le fichier, appuyez sur + Y + puis + ENTER +.

Vous pouvez activer la nouvelle configuration en utilisant la commande + source:

À partir de maintenant, la télémétrie sera désactivée au démarrage.

À ce stade, vous avez le runtime .NET Core, la prise en charge des langues et les bibliothèques installées, vous permettant d’exécuter et de créer des applications .NET. La CLI + dotnet + est également disponible pour la gestion du code source et des fichiers binaires .NET. Vous pouvez commencer à créer des projets F #, mais comme mentionné précédemment, l’environnement .NET Core ne fournit pas toutes les constructions nécessaires pour fonctionner de manière totalement multi-plateforme. Pour l’instant, vous ne pouvez pas l’utiliser pour développer des applications mobiles, par exemple.

Afin de résoudre ce problème, vous allez installer F # à nouveau à l’étape suivante, mais cette fois avec Mono.

Vous pouvez utiliser Mono pour combler les lacunes restantes en matière de capacité laissées par .NET Core. Mono et .NET Core reposent tous deux sur la même bibliothèque standard et prennent en charge les langages .NET, mais c’est là que se termine la similarité. Ils utilisent différentes exécutions, différents CLI et différents compilateurs, ce qui leur permet d’être installés côte à côte pour créer un environnement de programmation plus fiable. Dans cette section, vous allez compléter votre environnement avec les outils Mono pour la programmation .NET et exécuter un programme F # à partir de la ligne de commande.

Une version de Mono est disponible dans les référentiels Ubuntu, mais cela peut être obsolète. Ajoutez plutôt le référentiel de paquets Mono] à votre gestionnaire de paquets: official:

Dans les commandes précédentes, vous avez utilisé + apt-key + pour récupérer les clés permettant de sécuriser les paquets transférés à partir des référentiels Mono officiels. Vous avez ensuite ajouté la source de packages Mono à votre liste de référentiels.

Avec une nouvelle liste de sources ajoutée pour APT, mettez à jour vos référentiels:

Ensuite, téléchargez les outils Mono. Contrairement à .NET Core, Mono n’inclut pas les outils F #. Vous devez donc le télécharger dans un package séparé. Installez + fsharp + et le méta-package + mono-complete + en utilisant la commande suivante:

Une fois cela fait, vous aurez le compilateur + fsharpc + et un shell interactif appelé + fsharpi + ou simplement FSI. FSI est un environnement, à l’intérieur du shell, qui reçoit l’entrée de l’utilisateur sous forme d’expression, l’évalue, puis affiche le résultat et attend une autre entrée. C’est comme si vous tapiez une commande dans le shell traditionnel et voyiez le résultat, sauf qu’ici, les entrées sont des expressions F #. FSI fournit une méthode rapide pour tester le code ou exécuter des scripts.

Activez FSI avec la commande suivante:

Ceci démarrera la session interactive et remplacera votre invite habituelle par l’invite + fsharpi +:

Essayons une opération simple en utilisant la fonction + printfn + pour rendre un message passé en paramètre:

Vous recevrez le résultat suivant:

À partir de l’interaction précédente, + fsharpi + évalue l’expression en tant que valeur https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/unit-type [+ unit + `]. Le code est ensuite exécuté et le résultat est imprimé avec son type.

+ fsharpi + peut également exécuter un fichier contenant du code F #. Le script doit être nommé avec une extension + .fsx + et exécuté à partir du shell avec la commande:

Maintenant que vous savez que l’installation de F # fonctionne, quittez le shell avec:

Avec Mono et .NET Core installés, vous êtes maintenant prêt à écrire tout type de programme F #. FSI vous permettra de tester votre code et d’exécuter des scripts si nécessaire, mais les exécutions seront lentes. Pour que votre script F # soit exécuté, des étapes supplémentaires sont exécutées pour traduire le code source en artefacts compréhensibles par le processeur, d’où la lenteur. Pour remédier à cela, dans la section suivante, vous compilerez votre code avec .NET Core pour créer des fichiers binaires autonomes pouvant être exécutés immédiatement par la machine.

Dans cette étape, vous compilerez le code source F # via les compilateurs de ligne de commande fournis avec .NET Core. Cela vous permettra de rendre vos applications plus rapides et de produire des packages exécutables prédéfinis pour des systèmes spécifiques, ce qui facilitera la distribution de votre programme.

Compiling est le processus de transformation qui convertit le code source en fichier binaire. Le logiciel qui effectue cette conversion s’appelle un compilateur. .NET Core s’appuie sur la CLI + dotnet + pour effectuer la compilation. Pour démontrer cela, vous allez créer une source F # de base pour examiner les cas de compilation.

La CLI + dotnet + fournit un ensemble complet d’outils de génération d’applications. En général, une association d’une commande et du pilote + dotnet + est utilisée dans le shell pour terminer une tâche. Par exemple:

Ce qui suit va créer un nouveau projet de console appelé + FSharpHello +. L’option + -lang + définit le langage de programmation avec lequel vous allez coder, tandis que l’option + -o + crée un répertoire dans lequel placer la sortie.

Une fois cela fait, naviguez dans le répertoire du projet que vous venez de créer:

Ce répertoire contient le fichier de configuration du projet + .fsproj + et le dossier + obj + qui est utilisé pour stocker les fichiers d’objet temporaires. Il existe également le fichier + Program.fs + où votre code source par défaut existe. Ouvrez-le dans votre éditeur de texte:

Le fichier a été automatiquement rempli avec un programme * Hello World *:

Program.fs

Dans ce code, vous commencez à importer le module + System + avec + open System +, puis vous définissez le point d’entrée du programme, c’est-à-dire l’emplacement où le programme démarre lorsqu’il est lancé à partir du shell. La fonction + main appelle un message` + Hello World` sur la console et arrête le programme (+ renvoie un code de sortie entier +).

Quitter le fichier.

Pour compiler et exécuter ce code, utilisez ce qui suit dans le répertoire de projet + ~ / +:

Le programme s’exécutera en imprimant la sortie suivante à l’écran:

Notez qu’il a fallu un certain temps pour que ce programme s’exécute, comme avec le FSI. Comme nous l’avons déjà mentionné, il est possible d’exécuter cette tâche plus rapidement en générant un exécutable, c’est-à-dire un fichier binaire pouvant être exécuté directement par le système d’exploitation. Voici comment y parvenir:

Cela produira le fichier exécutable + bin / release / netcoreapp / linux-x64 / publish / .dll +. Il s’agit d’une bibliothèque partagée qui fonctionnera sur une architecture Linux 64 bits. Pour exporter un exécutable générique pour les systèmes macOS, vous devez remplacer l’identificateur d’exécution + linux-x64 + (RID. ) avec + osx-x64 +.

Maintenant, exécutez le fichier avec la commande suivante:

Cette fois, vous recevrez la sortie beaucoup plus rapidement, car le programme est déjà traduit en binaire.

Maintenant que vous savez comment compiler dans .NET Core, voyons comment Mono compile des programmes avec la commande dédiée + fsharpc +.

Le processus de compilation de Mono est similaire à celui de .NET Core, mais cette fois, une commande spécifique est utilisée pour compiler le programme. La commande + fsharpc + est l’outil, et il a été créé uniquement pour la compilation.

Cette fois, créez un fichier + hello.fs + et écrivez du code F #. Tout d’abord, retournez à votre répertoire personnel:

Ensuite, ouvrez un nouveau fichier nommé + hello.fs +:

Ajoutez la ligne suivante au fichier:

bonjour.fs

Comme précédemment, cela importe le module + System + ou l’espace de noms, vous donnant accès à des fonctions système et à des objets tels que + Console +.

Maintenant, ajoutez quelques lignes de code supplémentaires:

bonjour.fs

Ces nouvelles lignes définissent la fonction + hello () + pour lire les entrées utilisateur et imprimer un message de retour.

Maintenant, vous pouvez ajouter les dernières lignes:

bonjour.fs

Ici, vous appelez la fonction + hello () +, puis utilisez la méthode + ReadKey () + pour mettre fin au programme avec une frappe finale.

Enregistrez et quittez le fichier.

Maintenant, avec la commande + fsharpc +, utilisez l’indicateur + -o + pour définir le nom du fichier de sortie et compiler votre code source + hello.fs + comme ceci:

La commande précédente générera un fichier exécutable + hello + que vous pourrez exécuter avec la commande + mono +:

Cela vous donne la sortie suivante et attend l’entrée de l’utilisateur:

Si vous tapez ++, vous obtiendrez ce qui suit.

Appuyez sur une touche finale, et le programme se terminera.

Toutes nos félicitations! Vous avez écrit et compilé votre premier programme F #, à la fois avec Mono et .NET Core.

Dans ce tutoriel, vous avez installé des outils pour la programmation F #, couvrant à la fois les environnements .NET Core et Mono. Vous avez également testé des exemples de code F # et construit des exécutables. Ce sont les premiers pas vers l’apprentissage de ce langage fonctionnel et pratique.

Les prochaines étapes pourraient être learn the language et entrer en contact avec le https: //fsharp.org/community/projects/[community]. De plus, avec la complexité croissante des projets, vous devrez peut-être gérer le code et les ressources plus efficacement. Les gestionnaires de paquets tels que https://www.nuget.org [NuGet] ou Paket sont des ponts vers le puissant écosystème construit autour de .NET et des outils de choix pour organiser programmes.