TOC

Installieren von F # und Einrichten einer lokalen Programmierumgebung unter Ubuntu 18.04

Der Autor hat die Free Software Foundation ausgewählt, um eine Spende als Teil der Write für zu erhalten DOnations program.

Einführung

https://fsharp.org [F #] ist eine Open-Source-Programmiersprache, die ursprünglich von Microsoft Research entwickelt wurde, um .NET, die Tools, Bibliotheken und Sprachen von Microsoft, die erstellt werden sollen, zu erweitern Anwendungen und Dienste. Neben seiner bemerkenswert kurzen Syntax unterstützt F # mehrere paradigms, was bedeutet, dass es verschiedene Arten der Codestrukturierung ausführen kann, obwohl es in erster Linie darauf ausgelegt ist, den funktionalen Programmieransatz zu nutzen .

Die Annahme eines bestimmten Paradigmas oder eines Codestils bestimmt die Art und Weise, wie wir unsere Programmierproblemlösung denken und organisieren. Mit einem imperativen Ansatz wird das Designmodell in Sprachen wie C++ oder Java verwendet Der Entwickler beschreibt Schritt für Schritt, wie der Computer eine Aufgabe ausführen muss. Es geht darum, eine Folge von Anweisungen zu schreiben, die den Speicherstatus bei der Programmausführung ändern. Dies funktioniert einwandfrei, bis wir auf einige unregelmäßige Situationen stoßen. Stellen Sie sich zum Beispiel ein shared object vor, das von mehreren Anwendungen gleichzeitig verwendet wird. Möglicherweise möchten wir den Wert gleichzeitig mit der Änderung durch eine andere Komponente lesen. Dies sind laufende Aktionen an einem Speicherort, die zu Dateninkonsistenz und undefiniertem Verhalten führen können.

In functional code design verhindern wir dieses Problem, indem wir die Verwendung von mutable states oder states thats minimieren kann sich ändern, nachdem wir sie gemacht haben. Funktion ist hier das Schlüsselwort, das sich auf mathematische Transformationen für einige als Argumente bereitgestellte Informationen bezieht. Ein Funktionscode drückt aus, was das Programm ist, indem er die Lösung als Satz auszuführender Funktionen zusammensetzt. Normalerweise bauen wir Logikebenen mit Funktionen auf, die eine andere Funktion zurückgeben oder andere Funktionen als Eingaben verwenden können.

Die funktionale Programmierung mit F # bietet eine Reihe von Vorteilen:

  • Eine lesbarere und aussagekräftigere Syntax, die die Programmwartbarkeit verbessert.

  • Ein Code, der weniger anfällig für Brüche und einfacher zu debuggen ist, da statusfreie Funktionen zum Testen isoliert werden können.

  • Native Konstrukte, die eine asynchrone Programmierung und eine sicherere Parallelität ermöglichen.

  • Zugriff auf alle vorhandenen Tools in der .NET-Welt, einschließlich der von der Community freigegebenen Pakete.

Laufzeit auswählen

Da F # plattformübergreifend ist, ist die Beibehaltung eines ähnlichen Ausführungsmodellverhaltens über verschiedene Betriebssysteme hinweg unerlässlich. .NET erreicht dies mittels einer Laufzeitumgebung. Ein Laufzeitsystem ist eine Software, die die Ausführung eines mit einer bestimmten Programmiersprache geschriebenen Programms koordiniert und unter anderem die Schnittstellen zum Betriebssystem und zur Speicherverwaltung verwaltet.

Tatsächlich stehen unter Linux zwei .NET-Laufzeitimplementierungen zur Verfügung: .NET Core und https://www.mono-project.com [Mono]. . Früher funktionierte .NET nur unter Windows. In jenen Tagen konnte man auf das Community-Mono-Projekt zurückgreifen, um .NET-Anwendungen auf anderen Plattformen wie Linux und macOS auszuführen. Anschließend führte Microsoft .NET Core ein, eine schnellere, modulare Teilmenge des ursprünglichen .NET-Frameworks, um auf mehrere Plattformen abzuzielen.

Zum Zeitpunkt der Veröffentlichung dieses Lernprogramms können beide zum Erstellen von Webanwendungen oder Befehlszeilendienstprogrammen verwendet werden. .NET Core wird jedoch nicht mit Modellen zum Erstellen von GUI-Desktopanwendungen unter Linux und Mac OS ausgeliefert, während Mono die einzige Plattform ist, die Mobil- und Spieleplattformen unterstützt. Es ist wichtig, diese Unterschiede zu kennen, da die von Ihnen ausgewählte Laufzeit die zu erstellenden Programme beeinflusst. Sie können auch .NET Core und Mono installieren, um alle Anwendungsfälle zu berücksichtigen und einen produktiveren Stack zu erstellen.

In diesem Tutorial richten Sie unter Ubuntu 18.04 eine F # -Programmierumgebung ein, die sowohl .NET Core- als auch Mono-Laufzeiten verwendet. Anschließend schreiben Sie einige Codebeispiele, um die Erstellungs- und Kompilierungsmethoden zu testen und zu überprüfen.

Voraussetzungen

Um dieses Tutorial abzuschließen, benötigen Sie grundlegende Kenntnisse über die Befehlszeile und einen Computer mit Ubuntu 18.04 und einem https://www.digitalocean.com/community/tutorials/initial -server-setup-with-ubuntu-18-04 # step-2-% E2% 80% 94-erstelle-einen-neuen-benutzer [nicht-root-benutzer mit sudo-berechtigungen].

Schritt 1 - Installieren von F # mit .NET Core

Microsoft bietet das *.NET Core Software Development Kit (SDK) * für F # -Entwickler an. Ein Software Development Kit besteht aus einer Reihe von Programmiertools, mit denen Programmierer spezielle Anwendungen erstellen und diese an verschiedene Betriebssysteme anpassen können. Es enthält neben anderen Komponenten traditionell einen Texteditor, Sprachunterstützung, eine Laufzeitumgebung und einen Compiler. In diesem Schritt installieren Sie dieses SDK. Zunächst müssen Sie jedoch das Microsoft-Repository registrieren und einige Abhängigkeiten abrufen.

Sie schließen die Installation und Einrichtung über die Befehlszeile ab. Dies ist eine nicht grafische Methode, um mit Ihrem Computer zu interagieren. Das heißt, anstatt auf Schaltflächen zu klicken, geben Sie Text ein und erhalten auch Text-Feedback von Ihrem Computer.

Die Befehlszeile, auch als shell oder terminal bezeichnet, kann dazu beitragen, viele der Aufgaben, die Sie täglich auf einem Computer ausführen, zu ändern und zu automatisieren. Sie ist ein unverzichtbares Werkzeug für Softwareentwickler. Es müssen viele Terminalbefehle gelernt werden, mit denen Sie leistungsstärkere Aufgaben ausführen können. Weitere Informationen zur Befehlszeile finden Sie im Einführung in das Linux-Terminal -Tutorial.

Unter Ubuntu 18.04 finden Sie die Terminal-Anwendung, indem Sie auf das Ubuntu-Symbol in der oberen linken Ecke Ihres Bildschirms klicken und "+ terminal " in die Suchleiste eingeben. Klicken Sie auf das Terminal-Anwendungssymbol, um es zu öffnen. Alternativ können Sie auch gleichzeitig die Tasten " STRG", "+ ALT" und "+ T +" auf der Tastatur drücken, um die Terminal-Anwendung automatisch zu öffnen.

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

Nachdem Sie das Terminal geöffnet haben, können Sie mit dem Befehl "+ wget +" ein Paket herunterladen, das einige erforderliche Dateien, die Microsoft-Repository-Konfigurationen und einen Schlüssel für die Serverkommunikation enthält.

wget -q https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb

Fügen Sie nun das Microsoft-Repository hinzu und installieren Sie die Pakete mit der Anweisung + dpkg -i + auf Ihrem System.

sudo dpkg -i packages-microsoft-prod.deb

Aktivieren Sie als Nächstes das Universe-Repository, das unter Ubuntu ein von der Community verwaltetes Archiv von Software ist, das kostenlos und Open Source ist. Dadurch erhalten Sie Zugriff auf "+ apt-transport-https +", eine Abhängigkeit zum Aktivieren des APT-Transports für den Ubuntu-Paketmanager über HTTPS.

sudo add-apt-repository universe
sudo apt install apt-transport-https

Aktualisieren Sie anschließend die verfügbaren Downloads:

sudo apt update

Schließlich installieren Sie die current version des .NET SDK. In diesem Tutorial wird Version 2.2 verwendet:

sudo apt install dotnet-sdk-

Nachdem Sie das .NET SDK installiert haben, können Sie schnell überprüfen, ob alles funktioniert hat, indem Sie die .NET Core-Befehlszeilenschnittstelle (Command Line Interface, CLI) ausprobieren, die in der Shell verfügbar ist, sobald das SDK heruntergeladen und installiert wurde. Zeigen Sie Informationen zu Ihrem .NET-Setup an, indem Sie Folgendes in Ihr Terminal eingeben:

dotnet --info

Wenn Sie zum ersten Mal einen Befehl + dotnet + ausführen, wird ein Textabschnitt wie folgt angezeigt:

OutputWelcome to .NET Core!
---------------------
Learn more about .NET Core: https://aka.ms/dotnet-docs
Use 'dotnet --help' to see available commands or visit: https://aka.ms/dotnet-cli-docs

Telemetry
---------
The .NET Core tools collect usage data in order to help us improve your experience. The data is anonymous and doesn't include command-line arguments. The data is collected by Microsoft and shared with the community. You can opt-out of telemetry by setting the DOTNET_CLI_TELEMETRY_OPTOUT environment variable to '1' or 'true' using your favorite shell.

Read more about .NET Core CLI Tools telemetry: https://aka.ms/dotnet-cli-telemetry
...

Diese Benachrichtigung bezieht sich auf gesammelte Daten und erklärt, dass einige .NET CLI-Befehle Verwendungsinformationen an Microsoft senden. Sie werden dies gleich deaktivieren. Sehen Sie sich zunächst die Ausgabe von "+ dotnet --info +" an.

Nach einem kurzen Moment listet das Terminal Informationen zu Ihrer .NET-Installation auf:

Output.NET Core SDK (reflecting any global.json):
Version:
Commit:    236713b0b7

Runtime Environment:
OS Name:     ubuntu
OS Version:  18.04
OS Platform: Linux
RID:         ubuntu.18.04-x64
Base Path:   /usr/share/dotnet/sdk//

Host (useful for support):
 Version:
 Commit:  1249f08fed

.NET Core SDKs installed:
  [/usr/share/dotnet/sdk]

.NET Core runtimes installed:
 Microsoft.AspNetCore.All  [/usr/share/dotnet/shared/Microsoft.AspNetCore.All]
 Microsoft.AspNetCore.App  [/usr/share/dotnet/shared/Microsoft.AspNetCore.App]
 Microsoft.NETCore.App  [/usr/share/dotnet/shared/Microsoft.NETCore.App]

To install additional .NET Core runtimes or SDKs:
 https://aka.ms/dotnet-download

Abhängig von der SDK-Version kann die Ausgabe leicht abweichen, dies bestätigt jedoch, dass .NET Core einsatzbereit ist.

Wie bereits erwähnt, können mit der Telemetriefunktion einige .NET CLI-Befehle Nutzungsinformationen an Microsoft senden. Es ist standardmäßig aktiviert und kann deaktiviert werden, indem die Umgebungsvariable + DOTNET \ _CLI \ _TELEMETRY_OPTOUT + auf + 1 + gesetzt wird. Fügen Sie dazu eine neue Zeile zu Ihrer Umgebungsanpassungsdatei "+ .profile " hinzu, indem Sie sie in Ihrem Texteditor öffnen. Für dieses Tutorial werden wir ` nano +` verwenden:

nano ~/.profile

Fügen Sie die folgende Zeile am Ende von "+ .profile +" hinzu:

~ / .profile

. . .
export DOTNET_CLI_TELEMETRY_OPTOUT=1

Beenden Sie "+ nano", indem Sie die Tasten "+ CTRL" und "+ X" drücken. Wenn Sie aufgefordert werden, die Datei zu speichern, drücken Sie + Y + und dann + ENTER +.

Sie können die neue Konfiguration mit dem Befehl + source aktivieren:

source ~/.profile

Ab jetzt wird die Telemetrie beim Start deaktiviert.

Zu diesem Zeitpunkt sind die .NET Core-Laufzeit, die Sprachunterstützung und die Bibliotheken installiert, sodass Sie einige .NET-Anwendungen ausführen und erstellen können. Die + dotnet + CLI ist auch für die Verwaltung von .NET-Quellcode und Binärdateien verfügbar. Sie könnten mit dem Erstellen von F # -Projekten beginnen, aber wie bereits erwähnt, bietet die .NET Core-Umgebung nicht alle erforderlichen Konstrukte, um vollständig plattformübergreifend zu sein. Momentan können Sie damit beispielsweise keine mobilen Anwendungen entwickeln.

Um dieses Problem zu lösen, installieren Sie im nächsten Schritt F # erneut, diesmal jedoch mit Mono.

Schritt 2 - Installieren von F # mit Mono

Sie können Mono verwenden, um die verbleibenden Leistungslücken von .NET Core zu schließen. Mono und .NET Core basieren beide auf derselben Standardbibliothek und unterstützen beide .NET-Sprachen, aber hier endet die Ähnlichkeit. Sie verwenden unterschiedliche Laufzeiten, unterschiedliche CLIs und unterschiedliche Compiler, sodass sie nebeneinander installiert werden können, um eine zuverlässigere Programmierumgebung zu erstellen. In diesem Abschnitt ergänzen Sie Ihre Umgebung mit den Mono-Tools für die .NET-Programmierung und führen ein F # -Programm über die Befehlszeile aus.

Eine Version von Mono ist in den Ubuntu-Repositories verfügbar, diese kann jedoch veraltet sein. Fügen Sie stattdessen das official Mono package repository zu Ihrem Paketmanager hinzu:

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF
echo "deb https://download.mono-project.com/repo/ubuntu stable-bionic main" | sudo tee /etc/apt/sources.list.d/mono-official-stable.list

In den vorhergehenden Befehlen haben Sie "+ apt-key +" verwendet, um Schlüssel zum Sichern von Paketen abzurufen, die aus den offiziellen Mono-Repositorys übertragen wurden. Anschließend haben Sie die Quelle für Mono-Pakete zu Ihrer Repository-Liste hinzugefügt.

Aktualisieren Sie Ihre Repositorys, indem Sie eine neue Quellenliste für APT hinzufügen:

sudo apt update

Laden Sie als Nächstes die Mono-Tools herunter. Im Gegensatz zu .NET Core enthält Mono keine F # -Tools, sodass Sie es als separates Paket herunterladen. Installieren Sie + fsharp + und das Meta-Paket + mono-complete + mit dem folgenden Befehl:

sudo apt install mono-complete fsharp

Danach haben Sie den Compiler "+ fsharpc " und eine interaktive Shell mit dem Namen " fsharpi +" oder einfach FSI. FSI ist eine Umgebung in der Shell, die Benutzereingaben als Ausdruck empfängt, diese auswertet, das Ergebnis ausgibt und auf eine weitere Eingabe wartet. Es ist so, als würde man einen Befehl in die traditionelle Shell eingeben und das Ergebnis sehen, mit der Ausnahme, dass Eingaben F # -Ausdrücke sind. FSI bietet eine schnelle Methode zum Testen von Code oder zum Ausführen von Skripten.

Aktivieren Sie FSI mit dem folgenden Befehl:

fsharpi

Dies startet die interaktive Sitzung und ersetzt Ihre reguläre Eingabeaufforderung durch die Eingabeaufforderung + fsharpi +:

OutputMicrosoft (R) F# Interactive version 4.1
Copyright (c) Microsoft Corporation. All Rights Reserved.

For help type #help;;

>
Sie können zur Standard-Shell zurückkehren, indem Sie `+ # quit

` ausführen. In ` fsharpi +` endet jede Befehlszeile mit einem doppelten Semikolon.

Versuchen wir eine einfache Operation mit der Funktion "+ printfn +", um eine als Parameter übergebene Nachricht zu rendern:

printfn "Hello World!";;

Sie erhalten folgende Ausgabe:

OutputHello World!
val it : unit = ()

>

Aus der vorhergehenden Interaktion wertet + fsharpi + den Ausdruck als https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/unit-type [+ unit + type]] aus. Der Code wird dann ausgeführt und das Ergebnis mit seinem Typ gedruckt.

+ fsharpi + kann auch eine Datei ausführen, die F # -Code enthält. Das Skript muss mit der Erweiterung "+ .fsx +" benannt und in der Shell mit dem folgenden Befehl ausgeführt werden:

fsharpi .fsx

Nachdem Sie wissen, dass die F # -Installation funktioniert, verlassen Sie die Shell mit:

> #quit;;

Mit Mono und .NET Core können Sie jetzt alle Arten von F # -Programmen schreiben. Mit FSI können Sie Ihren Code testen und bei Bedarf einige Skripte ausführen, die Ausführung ist jedoch langsam. Zur Ausführung Ihres F # -Skripts werden zusätzliche Schritte ausgeführt, um den Quellcode in Artefakte zu übersetzen, die für den Prozessor verständlich sind, daher die Langsamkeit. Um dies zu beheben, kompilieren Sie im nächsten Abschnitt Ihren Code mit .NET Core und erstellen eigenständige Binärdateien, die sofort vom Computer ausgeführt werden können.

Schritt 3 - Schreiben und Kompilieren von F # -Programmen mit .NET Core

In diesem Schritt kompilieren Sie den F # -Quellcode über die mit .NET Core gelieferten Befehlszeilencompiler. Auf diese Weise können Sie Ihre Anwendungen beschleunigen und voreingestellte ausführbare Pakete für bestimmte Systeme erstellen, wodurch die Verteilung Ihres Programms vereinfacht wird.

Compiling ist der Transformationsprozess, der den Quellcode in eine Binärdatei umwandelt. Die Software, die diese Konvertierung durchführt, wird als Compiler bezeichnet. .NET Core benötigt die + dotnet + CLI, um die Kompilierung durchzuführen. Um dies zu demonstrieren, erstellen Sie eine grundlegende F # -Quelle, um die Kompilierungsfälle zu überprüfen.

Die + dotnet + CLI bietet eine vollständige Toolchain zur Anwendungserstellung. Im Allgemeinen wird eine Verknüpfung eines Befehls mit dem + dotnet + - Treiber in der Shell verwendet, um eine Aufgabe abzuschließen. Zum Beispiel:

  • + dotnet new + erstellt ein Projekt

  • + dotnet build + erstellt ein Projekt und all seine Abhängigkeiten

  • + dotnet add package fügt einen Paketverweis zu einer Projektdatei hinzu

Im Folgenden wird ein neues Konsolenprojekt mit dem Namen "+ FSharpHello " erstellt. Die Option " -lang " legt die Programmiersprache fest, mit der Sie programmieren, während die Option " -o +" ein Verzeichnis erstellt, in dem die Ausgabe abgelegt werden soll.

dotnet new console -lang F# -o

Navigieren Sie anschließend in Ihr neu erstelltes Projektverzeichnis:

cd

Dieses Verzeichnis enthält die Projektkonfigurationsdatei "+ .fsproj " und den Ordner " obj ", in dem temporäre Objektdateien gespeichert werden. Es gibt auch die Datei ` Program.fs +`, in der sich Ihr Standardquellcode befindet. Öffne es in deinem Texteditor:

nano Program.fs

Die Datei wurde automatisch mit einem * Hello World * -Programm gefüllt:

Program.fs

// Learn more about F# at http://fsharp.org

open System

[<EntryPoint>]
let main argv =
   printfn "Hello World from F#!"
   0 // return an integer exit code

In diesem Code starten Sie den Import des Moduls "+ System " mit " open System " und definieren dann den Programmeinstiegspunkt, d. H. Die Stelle, an der das Programm startet, wenn es von der Shell aus gestartet wird. Die " main" -Funktion ruft das Drucken einer "+ Hello World" -Nachricht auf der Konsole auf und stoppt das Programm ("+" gibt einen ganzzahligen Exit-Code zurück + ").

Beenden Sie die Datei.

Verwenden Sie zum Kompilieren und Ausführen dieses Codes Folgendes aus dem Projektverzeichnis "+ ~ / +":

dotnet run

Das Programm wird ausgeführt und gibt die folgende Ausgabe auf dem Bildschirm aus:

OutputHello World from F#!

Beachten Sie, dass es eine Weile gedauert hat, bis dieses Programm ausgeführt wurde, genau wie beim FSI. Wie bereits erwähnt, ist es möglich, dies schneller auszuführen, indem eine ausführbare Datei generiert wird, d. H. Eine Binärdatei, die direkt vom Betriebssystem ausgeführt werden kann. So erreichen Sie das:

dotnet publish -c release -r linux-x64

Dadurch wird die ausführbare Datei + bin / release / netcoreapp / linux-x64 / publish / .dll + erstellt. Dies ist eine gemeinsam genutzte Bibliothek, die auf einer 64-Bit-Linux-Architektur ausgeführt wird. Um eine generische ausführbare Datei für MacOS-Systeme zu exportieren, ersetzen Sie die Laufzeitkennung "+ linux-x64 " (https://docs.microsoft.com/en-us/dotnet/core/rid-catalog#using-rids[RID). ) mit ` osx-x64 +`.

Führen Sie nun die Datei mit folgendem Befehl aus:

dotnet bin/release/netcoreapp/linux-x64/publish/.dll

Dieses Mal erhalten Sie die Ausgabe viel schneller, da das Programm bereits in eine Binärdatei übersetzt ist.

Nachdem Sie nun wissen, wie in .NET Core kompiliert wird, wollen wir uns ansehen, wie Mono Programme mit dem dedizierten Befehl "+ fsharpc +" kompiliert.

Schritt 4 - Schreiben und Kompilieren von F # -Programmen mit Mono

Der Kompilierungsprozess von Mono ähnelt dem von .NET Core, diesmal wird jedoch ein bestimmter Befehl zum Kompilieren des Programms verwendet. Der Befehl + fsharpc + ist das Werkzeug und wurde nur zum Kompilieren erstellt.

Erstellen Sie diesmal eine + hello.fs + - Datei und schreiben Sie einen F # -Code. Kehren Sie zunächst in Ihr Ausgangsverzeichnis zurück:

cd

Öffnen Sie als nächstes eine neue Datei mit dem Namen + hello.fs +:

nano hello.fs

Fügen Sie der Datei die folgende Zeile hinzu:

hallo.fs

Wie bereits erwähnt, wird das Modul "+ System " oder der Namespace importiert, sodass Sie auf integrierte Systemfunktionen und Objekte wie " Console +" zugreifen können.

Fügen Sie nun einige weitere Codezeilen hinzu:

hallo.fs

open System

Diese neuen Zeilen definieren die Funktion + hello () +, um Benutzereingaben zu lesen und eine Rückmeldung auszudrucken.

Jetzt können Sie die letzten Zeilen hinzufügen:

hallo.fs

open System

let hello() =
   printf "Who are you? "
   let name = Console.ReadLine()
   printfn "Oh, Hello %s!\nI'm F#." name

Hier rufen Sie die Funktion + hello () + auf und verwenden dann die Methode + ReadKey () +, um das Programm mit einem letzten Tastendruck zu beenden.

Speichern und schließen Sie die Datei.

Verwenden Sie jetzt mit dem Befehl "+ fsharpc " das Flag " -o ", um den Ausgabedateinamen zu definieren und Ihren Quellcode " hello.fs +" wie folgt zu kompilieren:

fsharpc hello.fs -o hello

Der vorhergehende Befehl generiert eine ausführbare Datei, die Sie mit dem Befehl "+ mono +" ausführen können:

mono hello

Dadurch erhalten Sie die folgende Ausgabe und warten auf Benutzereingaben:

OutputWho are you?

Wenn Sie "++" eingeben, erhalten Sie Folgendes.

OutputOh, Hello !
I'm F#.

Drücken Sie einen letzten Tastendruck, und das Programm wird beendet.

Herzliche Glückwünsche! Sie haben Ihr erstes F # -Programm mit Mono und .NET Core geschrieben und kompiliert.

Fazit

In diesem Lernprogramm haben Sie Tools für die F # -Programmierung installiert, die sowohl .NET Core- als auch Mono-Umgebungen abdecken. Sie haben auch Beispiele für F # -Code getestet und ausführbare Dateien erstellt. Dies sind die ersten Schritte zum Erlernen dieser praktischen Funktionssprache.

Die nächsten Schritte könnten sein, learn the language und sich mit https in Verbindung zu setzen: //fsharp.org/community/projects/[community]. Da Projekte immer komplexer werden, müssen Sie möglicherweise Code und Ressourcen effizienter verwalten. Paketmanager wie https://www.nuget.org [NuGet] oder Paket sind Brücken zu dem starken Ökosystem, das auf .NET basiert, und Tools der Wahl für die Organisation großer Datenmengen Programme.

Related