DEV Community: Paul Arizpe

Oh-my-Powershell

Paul Arizpe — Tue, 07 Sep 2021 02:54:30 +0000

Bienvenue dans un nouvel article, cette fois dédié à Powershell.
Étant Développeur avec le system Windows, la majorité de temps quand nous travaillons avec WSL ou directement dans un environnement Linux, nous utilisons zsh pour donner de plus personnalité au terminal, cependant, quand nous retournons à notre environnement Windows, nous n'avons pas ces styles et couleurs dans notre Terminal.

Heureusement, j'ai trouvé en recherchant un solution pour windows, ainsi j'ai trouvé Oh-My-Posh .
Ce script permet de donner un peu plus de personnalisation à la terminal Powershell, similaire au zsh.

Pour y installer, nous devons avoir installé Powershell. Si vous êtes développeur .Net, il en est possible que vous ayez une version vielle.

Puis on doit ouvrir une fenêtre de Powershell en mode Administrateur, alors on va exécuter les commandes suivantes :

PowerShell 7.1.4
Copyright (c) Microsoft Corporation.

https://aka.ms/powershell
Type 'help' to get help.

PS C:\Users\edens-zero> Install-Module oh-my-posh -Scope AllUsers
PS C:\Users\edens-zero> Import-Module oh-my-posh
PS C:\Users\edens-zero> Get-PoshThemes
PS C:\Users\edens-zero> Get-PoshThemes -list

Après que le processus d'installation termine, on doit télécharger la typographie Nerd Fonts puisque Oh-My-Posh en a besoin. Un fois télécharge dans notre ordinateur, il sera nécessaire de l'installer, car les thèmes ont besoin de celle.

Après on va créer un nouvel fichier en exécutant la ligne suivant :

PS C:\Users\edens-zero> notepad $PROFILE.AllUsersAllHosts

# Si ça ne marche pas , vous pouvez utiliser 
PS C:\Users\edens-zero> notepad $PROFILE

Ça ouvrira le notepad, alors nous ajouterons la ligne suivante pour assigner un thème :

Set-PoshPrompt -Theme jandedobbeleer

Puis nous écrivons. $PROFILE et voilà !!! Powershell aura une meilleure présentation. Si vous utilisez WSL, vous devez modifier les paramètres et ajouter dans la section defaults la typographie Nerd Font installé. Par exemple :

{
    "profiles":
    {
        "defaults":
        {
            "fontFace": "FiraCode Nerd Font"
        }
    }
}

Finalement, Powershell semble à ZSH. N'hésitez pas si vous avez des commentaires ou des questions ! Et si vous aimez cet article, n'oubliez pas de donner votre like et le partager, à bientôt.

S1E1 - Instalando ZSH & ASDF en Ubuntu

Paul Arizpe — Tue, 24 Aug 2021 03:33:43 +0000

Hola a todos, y bienvenidos a una entrega mas, ahora en formato video y en español para su mayor comodidad. En esta ocasión comenzaremos realizando uno de mis articulos en Frances ZSH & ASDF sur WSL2 Ubuntu , ya que aprovechando de que obtuve una Raspberry Pi 4, aproveche para hacer este video. Espero les guste y no olviden dejar su Like & compartir para seguir trayendo mas contenido.

Data Science avec F#

Paul Arizpe — Sat, 31 Jul 2021 15:20:09 +0000

Bonjour à tous, aujourd’hui on retourne avec F# !!!! Pour vous donner un peu de contexte, en 2020 j’ai pris par un an le diplômât de Data Science dans la plateforme de Datacamp, grâce à une bourse de Facebook, j’ai appris quelques techniques de science de données, cependant, la majorité des cours utilisent Python pour travailler avec les données. Alors je rappel que F# et Scala s’utilisent aussi pour jouer avec les données.
En 2019, Microsoft a lancé .NET Core 3.0 et cela a donné aux Jupyter Notebooks le support pour utiliser .NET. Pour longtemps .NET utilisait IfSharp qui est une modification de Jupyter crée par la communauté de F#, maintenant on peut utiliser le Jupyter qui vient avec les outils d’Anaconda.
Dans cet article, je vais utiliser le laboratoire « Introduction to Jupyter Notebooks « que la plateforme Datacamp a pour enseigner leurs élevés comme fonctionne cet outil.

Jupyter Notebooks

Je parle sur Jupyter et ses Notebooks mais Qu’Est-ce que ce Jupyter ?
Il est un projet qui permet créer des documents interactifs, ces documents permettent exécuter code et montrer le résultat sur le même. D’abord, il travaille avec Python qui est le kernel du début et avec Markdown pour donner une meilleure présentation aux écrits. Pour utiliser cet outil, on doit installer Python et les requis qui demande Jupyter, or, pour faire cette installation facile, on peut utiliser Anaconda ou Docker.

Requis

Les requis sont très simples car il est possible qu’on ait ce logiciel déjà installé.
• Installez la suite Anaconda
• Installez le .NET CLI auquel on peut trouver F#
• Installez votre éditeur de code préféré, dans cet article, je vais utiliser VS Code
Pour y ajouter le kernel .Net, on doit exécuter les suivantes lignes du code dans une terminal après avoir installé le .NET CLI et Anacoda :

# Il faut installer l’outil dotnet-try
Terminal > dotnet tool install –global dotnet-try
# Pour installer le kernel
Terminal> dotnet try Jupyter install
# Pour vérifier que le kernel se soit bien installé 
Terminal> Jupyter kernelspec list

# Le résultat de la commande serait le suivant : 
Available kernels:
  .net-csharp      …\jupyter\kernels\.net-csharp
  .net-fsharp      ...\jupyter\kernels\.net-fsharp
  powershell       ...\jupyter\kernels\powershell
  pysparkkernel    ...\jupyter\kernels\pysparkkernel
  sparkkernel      ...\jupyter\kernels\sparkkernel
  sparkrkernel     ...\jupyter\kernels\sparkrkernel
  python3          ...\jupyter\kernels\python3

Désormais, on peut utiliser Jupyter avec .NET, alors on va exécuter dans la ligne de commande :

Terminal > cd Workspace
Workspace > jupyter lab

Cela va lever un serveur web dans le port 8888, si c’est la première fois, vous devez écrire un mot du passe. D’abord on peut regarder des sections qui ont différentes fonctionnalités, alors pour créer un nouveau cahier jupyter, on a 3 options dont F# est l’option auquel on va travailler dans cet article.

Atelier – En chargeant données dans un DataFrame

1- On va cliquer sur le Button « .NET (F#) «, alors ça va créer un nouveau fichier «Untitled1.ipynb« , puis on clique sur le Button « Garder « et après on clique sur le fichier pour le renommer.
2- Cliquez sur le cahier pour ajouter le code ou Markdown, dans ce cas on va ajouter le code :

3- Pour pouvoir utiliser des nugets packages dans jupyter, on utilise les directives de préprocesseur en écrivant la syntaxe :

#r « <nuget package> « ou si nous avons besoin de certaine version, on utilise la syntaxe :

#r « <nuget package, version «

Alors, on va ajouter les packages :

• FSharp.Data – ça nous permettra travailler facilement avec les données de type JSON, CSV, HTML, etc.

• Deedle – Il était inspiré dans le populaire package de Python : Pandas, alors ce package nous permets travailler avec Dataframes

• Xplot – Ce package semble un peu à Bokeh et Matplotlib, celui-ci nous va permettre faire des graphiques.

Dans cet atelier, on utilisera un fichier csv qui contient de l’information des températures parmi les années 1850 – 1960. Vous pouvez le télécharger ici

4- Pour charger ces données, on utilise Deedle et pour montrer le contenu, on emploi le méthode Print. Pour prendre certaine quantité des données, on utilise la propriété Rows et celle-ci a le méthode Between qui reçoit les indices de début et final où on prend l’information. Dans ce petit exemple, j’ai pris 3 éléments du Dataframe.

Atelier – En créant des graphiques avec Xplot

Désormais on savait comment charger un fichier CSV dans un DataFrame, alors on va montrer un graphique avec le package Xplot.

5- On crée une nouvelle cellule du type code et on import le nom d'espace Xplot. Pour créer un graphique, nous utilisons la syntaxe ([propriétes du graphique])

open XPlot.Plotly

let lineTrace1 =
    Scatter(
        x = <Tableaux des données>,
        y = <Tableaux des données>
    )

6- D'autre part, si nous avons besoins d'ajouter plus de style à notre graphique et qu’il soit plus compressible, on utilise la class Layout, puis on passe les propriétés dans leur constructeur. Pour ajouter un titre, on emploi la propriété title* du type **string. Si on a besoin de changer les titres de l’axis X ou Y, on utilise la propriété xaxis ou yaxis, par exemple si on a besoin de changer le titre de l’axis X , on déclare un nouveau élément du type Xaxis et on assigne un valeur sur son propriété *title.

let styledLayout =
        Layout(
            title = "Titre du graphique",
            xaxis =
                Xaxis(
                    title = "Titre xaxis",
                    showgrid = false,
                    zeroline = false
                ),
            yaxis =
                Yaxis(
                    title = "titre yaxis",
                    showline = false
                )
        )

7- On applique désormais tout ça pour créer notre graphique, ensuite nous utilisons les pipes pour joindre le code et montrer le graphique, finalement on exécute la cellule

open XPlot.Plotly

// Example
let year = globalTemp.GetColumn<int16>("year")
let degreesCelsius = globalTemp.GetColumn<double>("degrees_celsius")

let lineTrace1 =
    Scatter(
        x = year.Values,
        y = degreesCelsius.Values,
        name = ""
    )

let styledLayout =
    Layout(
        title = "Temperature 1850 - 2016",
        xaxis =
            Xaxis(
                title = "Years",
                showgrid = false,
                zeroline = false
            ),
        yaxis =
            Yaxis(
                title = "Degrees",
                showline = false
            )
    )

//
let chart = lineTrace1 |> Chart.Plot |> Chart.WithLayout styledLayout // |> Chart.Show
display(chart)

Voila, on a créé notre premier graphique :D

Atelier – Cartes

Si vous venez de Python, vous avez Folium pour montrer certaine information dans une carte, cependant, dans .NET n’a pas une librairie similaire mais on peut travailler avec une carte grâce à Xplot. Pour utiliser cette fonctionnalité, on doit importer l’espace de noms GoogleCharts. Celui-ci a beaucoup de classes, cependant, dans cet exemple, on utilisera Geo.

Geo reçoit des données du type tuple, c’est-à-dire dans ce format : Lat*Lng*String

8 – Pour présenter une carte, on importe GoogleCharts. Après on déclare une variable qui s’appellera companies lequel contiendra le code suivant :

// XPlot.GoogleCharts
open XPlot.GoogleCharts
// Declaration d'un variable de type Tableaux avec tuples (Lat, Long, "Label")
let companies = 
    [
        (37.4970,  127.0266, "Samsung: 20.5%")
        (37.3318, -122.0311, "Apple: 14.4%")
        (22.5431,  114.0579, "Huawei: 8.9%")
    ]

9 – Puis, on déclare une variable du type Options et on active la propriété showTooltips et la propriété displaymode tiendra la valeur : « markers «

let options = XPlot.GoogleCharts.Options(showTooltips = true, displayMode="markers")

11 – Finalement on joint tous les éléments en utilisant les pipes de F# et on verra la carte 😊

companies 
|> Chart.Geo
|> Chart.WithOptions options
|> Chart.Show

Voila !! Nous avons crée une carte qui a 3 markers

En bref, on a utilisé Jupyter avec F# en ajoutant le Kernel .NET grâce au package try. Cette combinaison entre Jupyter et .Net, nous permet montrer et partager nos recherches. Pour ce labo, je « transformais » le laboratoire de Datacamp « Introduction to Datacamp Projects « au format .NET en utilisant F#, aussi il est possible utiliser C#. Finalement Si vous aimez cet article, n'oubliez pas de donner votre like et le partager, à bientôt.

Dart pour C# Développeurs - Part 2

Paul Arizpe — Wed, 16 Jun 2021 04:16:39 +0000

Bonjour à tous et bienvenue à la deuxième partie de « Dart pour C# Développeurs «. La dernière fois, on a vu comment créer un projet Dart de type console en utilisant la ligne de commande, aussi on a vu la syntaxe basique et quelques types de donnés.

D’abord, on va commencer avec les types « classe «, ensuite les « Délégués «, « Interfaces » et « mixins.

Classes

Définir une classe en Dart, celle-ci ne devrait pas être une chose très difficile, puisqu’il semble beaucoup aux classes codé en C#.
Pour donner un peu de contexte, je vais utiliser comme un exemple une classe laquelle j'appellerai « Pokemon « :

// C# Code
public class Pokemon
{
        public int Id { get; set; }
        public string Name { get; set; }

        public Pokemon(int id, string name)
        {
            Id = id;
            Name = name;
        }
}

Utilisant Dart, celle-ci deviens:

class Pokemon {
  String Name = '';
  int Id = 0;

  Pokemon(int id, String name) {
    Name = name;
    Id = id;
  }
}

Bien que déclarer une classe soit facile, il est indispensable de remarquer que Dart n'a pas d'accesseurs comme en C#, c'est-à-dire que on ne doit pas indiquer si la classe est publique ou privé avec public ou private, or, il faut ajouter que ce type de déclaration existe d'une autre maniere, par exemple, pour le type privé, il est nécessaire d'ajouter _ avant du nom de notre variable, par exemple:

class Person {
  String _Name = '';

  String get Name {
    return _Name;
  }

  Person(String name) {
    _Name = name;
  }
}

var person = Person("Clara");
print(person.Name); // "Clara"
print(person._Name); // throws error

D'autre part, si nous avons besoins les bondis de l’héritage sur notre classe, c’est simple de donner cette compétence, par exemple en utilisant la classe Pokemon, on va ajouter la propriété ‘Type’ en utilisant cette caractéristique d’héritier.

// C# Code
public class Pokemon2: Pokemon
{
     public string Type { get; set; }

     Pokemon2(int id, string name, string type)
       : base(id, name)
     {
         Id = id;
         Name = name;
         Type = type;
     }
}

Pour faire cela en Dart, on doit utiliser le mot réservé : "extended".

// Dart code
class Pokemon2 extends Pokemon {
  String Type = '';
  Pokemon2(int id, String name, String type) : super(id, name) {
    Type = type;
  }
}

Très facile ! Désormais, vous pouvez créer vos propres classes et utiliser l'héritage, maintenant on va apprendre sur les interfaces.

Interfaces

En C#, nous pouvons définir la structure et les méthodes qui vont avoir nos classes, grâce aux interfaces, on peut faire un brouillon ou skeleton. Définir une interface en C# est très simple puisque on crée un fichier avec le code de l’interface, c’est-à-dire que ceux-ci suivent comment règle principal d’avoir le préfix «I« avant le nom, par exemple, l’interface de la classe « Pokemon » serait «IPokemon«.

// Code C#
interface IPokemon
{
   void Attack();
}

// Utilisation
public class PokemonWithInterface: IPokemon
{
     public void Attack()
     {
         Console.WriteLine("Attack !!!!");
     }
}

Néanmoins, Dart n’a pas d’interfacés, or, on peut utiliser une classe de type abstract pour donner un effet similaire en suivant les mêmes règles de définition. Par exemple :

// Code dart
abstract class IPokemon {
  void attack();
}

// utilisation
class PokemonWithInterface implements IPokemon {
  @override
  void attack() {
    print('Attack !!!!');
  }
}

Mixins

Avant de continuer avec le type Délégués, c’est important de savoir sur l’existence de mixins, lesquels permettent réutiliser parties de code sur multiples hiérarchies de classes. Ceux-ci sont pareils aux interfaces mais ils implémentent une fonctionnalité.

// création
class PokeMixin {
  void Attack2() => print("Attack Mixin");
}

// implementation
class Pokemon with PokeMixin implements IPokemon {
  String Name = '';
  int Id = 0;

  Pokemon(int id, String name) {
    Name = name;
    Id = id;
  }

  @override
  void attack() {
    print('Attack Method');
  }
}

// Exemple
var poke = Pokemon(25, 'Pikachu');
print(poke.Name); // Pikachu
poke.Attack2(); // Attack Mixin

Faites attention ! Je n'ai pas donner un exemple en C# puisque les mixins ne semblent pas aux mixins de Dart.

Délégués

Un délégué est un type qui représente des références aux méthodes avec une liste de paramètres et un type de retour particuliers. Lorsque vous instanciez un délégué, vous pouvez associer son instance à toute méthode ayant une signature et un type de retour compatibles.

// C# Code - Déclaration d'un délégué
public delegate void InfoDelegate(Pokemon pokemon);

// On doit définir un méthode qui corresponde à la signature du délégué.

public static void InfoMethod(Pokemon pokemon)
{
     Console.ForegroundColor = ConsoleColor.Cyan;
     Console.WriteLine("----------------");
     Console.WriteLine($"#{pokemon.Id} - {pokemon.Name}");
     Console.WriteLine("----------------");
}

// Utilisation
var pokemon = new Pokemon(25, "Pikachu");
InfoDelegate handler = InfoMethod;
handler(pokemon);

En Dart, nous pouvons utiliser le mot réservé typedef pour avoir le même effet.

// Dart Code - Déclaration d'un délégué
typedef InfoDelegate = void Function(Pokemon pokemon);

// Définition de méthode
void InfoMethod(Pokemon pokemon) {
  print('----------------');
  print('#${pokemon.Id} - ${pokemon.Name}');
  print('----------------');
}

// Exemple d'utilisation
var pokemon = Pokemon(25, 'Pikachu');
InfoDelegate handler = InfoMethod;
handler(pokemon);

Voila !! Désormais, on peut déclarer une classe, une interface, un mixin et un délégué. Pour le suivant et dernier article, on verra quelques exemples d'Async et Await et quelques exemples d'Events.
Finalement, Si vous aimez cet article, n'oubliez pas de donner votre like et du partager, à bientôt.

Dart pour C# Développeurs

Paul Arizpe — Sun, 11 Apr 2021 21:46:46 +0000

Bonjour à tous et bienvenue dans un nouvel article, dans cette occasionne, je vous enseignerais comment commencer programmer en Dartlang étant un développeur C#. Comme d’habitude je commencerais avec les requis, cependant, je supposerais que vous ayez installé asdf avec les plugins nécessaires pour travailler avec .NET et Dart.

Pour commencer avec les choses plus basiques de Dart, on va faire une comparaison entre les deux langues de programmation, puisqu’ls partagent certaines similitudes, pourtant, j’ai divisé cet article en 2 parties afin de vous donner une meilleure compression parmi les deux codes.

Création des projets de type Console.

Premièrement on va créer les projets de console pour Dart et C#. Pour créer un projet de console avec dart, il faut exécuter dans un Terminal la commande dart create -t console-full SampleConsoleApp, ensuite on va entrer dans le dossier crée avec le commande cd SampleConsoleApp. On peut regarder qu'il y a trois dossiers, or, le plus important sont bin et lib puisqu'ils contiendront notre code.

bin: Il contient le point d'exécution de l'application Dart. Il semble à Program.cs mais ici le fichier principal s'appellera avec le nom que nous le donnons pendant son création SampleConsoleApp.dart.
lib: Sur ce dossier, on va trouver les fichiers dart qui auront nos fonctions et clases. Par default, on trouve également un fichier avec le même nom que le fichier de bin, cependant, il contient le méthode calculate qui est appelé dans le point d'entrée de l'autre fichier.
test: Il contient tous les test qu'on va faire dans notre code. Par default, il contient un exemple.
pubspec.yml : Il contient les packages qu'on va utiliser dans notre projet. Il semble un peu à nuget, mais, tous les packages seraient télécharger de pub.dev

// Structure basique d'une application de console en Dart
// main.dart
void main(List<String> args) {
  print("Hello World!");
}
// Pour exécuter, il faut exécuter le suivante instruction: `dart run`

Créer une application de console dans Visual Studio, il sera facile, cependant, je vous laisse le contenu de Program.cs:

using System;

namespace CsharpToDart
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

En Dart, il n'existe pas le namespace comme en C#.
Pour pouvoir appeller les methodes de dossier lib, il faut suivre la syntaxe:
import 'package:/.dart'
Par exemple :
import 'package:SampleConsoleApp/SampleConsoleApp.dart'

Déclaration des variables et types de donnés.

En C#, on peut déclarer les variables en utilisant la syntaxe :

[type de donné] {nom de variable} = ;
Par exemple:
string message = "Bonjour";

Aussi si nous ne connaissons le type de donné, on peut utiliser var, pourtant, quand la valeur soit assignée, il obtiendra le type de donné, par exemple :

var {nom de variable} = ;
var name = "Joaquin"; // type string
var prix = 12.5; // type double ou float

Pour Dart, les choses sont similaires, seulement on va ajouter dynamic , const et final qui sont un peu semblables à var mais avec certains règles. Par exemple :

Dart
String message = "I'm a Dalek !!!";
var name = "The Doctor";
const prix = 12.5;
final message2 = "E X T E R M I N A T E !!!!"; // Même cas que const.
dynamic companyName = "Torchwood";

const: Une fois assignée, on ne peut changer la valeur de ce variable
final: Même cas que const, une fois assigné, la valeur ne pourra pas changer.
dynamic: Il est similaire à var, puisque celui-ci est utilisé quand on ne connait pas le type de donné. Il est utilisé beaucoup dans le type Map.

Désormais on va faire une petite comparaison entre les deux langues afin de connaitre quels sont les types des donnés les plus familials :

C# type	.NET type	Dart type	Dartlang type
bool	System.Boolean	bool	dart:core
byte	System.Byte	ByteBuffer	dart:typed_data
char	System.Char	String	dart:io
double	System.Double	double	dart:core
int	System.Int32	int	dart:core
uint	System.UInt32	Uint8	dart:ffi
nint	System.IntPtr	IntPtrPointer	dart:ffi
object	System.Object	Object	dart:core
string	System.String	String	dart:core
dynamic	System.Object	dynamic	dart:core
void		void

List, Maps, Sets

En C#, on a Arrays et Dictionary, cependant, si on a besoin de travailler avec Set, on requit d'installer Iesi Collections en cas d'utiliser .NET 4, tandis que la version 5, il vient avec HashSet.

Bien que C# ait ces structures des donnés, Dart a aussi les propres, cependant, pour le type array, il devient List, pour le Dictionary, il sera Map. Bien que C# n'ait pas supporté le type Set jusqu'à la version 5 de .NET, en Dart, on a le type Set.

Ici quelques exemples :

// List
List<String> names = ['Wanda', 'Pietro', 'Vision', 'Agatha', 'Mephisto'];
var names2 = <String>['Wanda', 'Pietro', 'Vision', 'Agatha', 'Mephisto'];

// Maps
var data = {'name': 'Wanda', 'lastname': 'Maximoff'};
var person = <String, String>{'name': 'Wanda', 'lastname': 'Maximoff'};
Map<String, String> data2 = {'name': 'Wanda', 'lastname': 'Maximoff'};

// Set
var names3 = {'Wanda', 'Pietro', 'Vision', 'Agatha', 'Mephisto'};
var persons = <String>{'Wanda', 'Pietro', 'Vision', 'Agatha', 'Mephisto'};
Set<String> characters= {'Wanda', 'Pietro', 'Vision', 'Agatha', 'Mephisto'};

Bref, on a vu les types de donnés qui ont pu trouver parmi les deux langues de programmation, cependant, il manque quelques structures et méthodes qu'on verra dans le suivant article. Si vous aimez cet article n'oublié de donner votre like et le partager, à bientôt.

Azure Functions avec F#

Paul Arizpe — Wed, 07 Apr 2021 20:44:07 +0000

Bonjour à tous dans un nouvel article sur la plateforme Dev.to. Dans cette occasionne, nous apprendrons brièvement comment faire une Azure Fonction en utilisant F# pour la développer.

Dans la première version d'Azure Fonctions, nous pouvions faire facilement une fonction en utilisant un script fsx, tandis que dans la dernière version d'Azure Fonctions nous devons précompiler et uploader nos scripts fs

Après de voir la documentation, j'ai découvert qu'il n'y a pas un bon exemple pour faire une fonction azure avec F#, donc la Template ne fonctionne pas alors j'ai déçu de faire ce petit tutoriel.

Requis

On a besoin d'installer le suivant logiciel:

Visual Studio Code ou votre éditeur du texte préféré.
Installez F# et NodeJS avec le package Azure Functions Core Tools
Installez le .NET Core CLI
Optionnellement vous pourriez créer un compte Microsoft Azure en cas de vouloir publier votre fonction.

Temp de code 1..2..3

Pas 1

D'abord on va vérifier notre installation alors on va ouvrir un terminal unix et écrire les commandes :

darkhero> func --version # 3.0.3388
darkhero> func templates list # on verra qu'il n'y a pas F# templates
darkhero> dotnet --version # 5.0.201

Malgré la faute d'une Template F#, on peut créer une fonctionne en exécutant le commande :

# Ce commande va créer notre fonctionne base dont F# sera la langue pour programmer
darkhero> dotnet new classlib --language F# --name HelloDevTo
darkhero> cd HelloDevTo && ls
HelloDevTo.fsproj  Library.fs  obj

On a 2 fichiers, HelloDevTo.fsproj et Library.fs, le premier contient l'information essentiel de notre projet F#, toutes les libraires vont ici. Library.fs est le fichier F# crée par default, alors on va l'effacer et créer le fichier HelloFunctions.fs

Pas 2

Pour ajouter la fonctionnalité d'une Azure Fonction dans notre code, il est nécessaire d'ajouter le package Microsoft.Net.Sdk.Functions, après on doit créer les fichiers host.json, local.settings.json & function.json.
Pour ajouter le package, on va exécuter la suivante ligne de code:

darkhero> dotnet add package Microsoft.NET.Sdk.Functions

Pour le fichier host.json, on va copier (ou écrire) le suivante code:

{
"version": "2.0",
}

Pour le fichier local.settings.json:

{
    "IsEncrypted": false,
    "Values": {
        "AzureWebJobsStorage": "UseDevelopmentStorage=true",
        "FUNCTIONS_WORKER_RUNTIME": "dotnet"
    }
}

Finalement dans le fichier function.json:

{
  "bindings": [
    {
      "type": "httpTrigger",
      "methods": [
        "get",
        "post"
      ],
      "authLevel": "anonymous",
      "name": "req"
    }
  ],
  "disabled": false
}

Après de tenir les fichiers nécessaires, on va modifier le fichier HelloDevTo.fsproj, car on doit ajouter les fichiers qu'on avait créés avant. Si on ouvre ce fichier, on verrait le suivant :

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netcoreapp3.1</TargetFramework>
    <GenerateDocumentationFile>true</GenerateDocumentationFile>
  </PropertyGroup>

  <ItemGroup>
    <Compile Include="Library.fs" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Sdk.Functions" Version="3.0.7" />
  </ItemGroup>

</Project>

Cependant, il n'y aura la configuration précise d'un azure fonction, pourtant, on va faire des petites modifications afin de lui donner la fonctionnalité. Pour faire cela, il n'est que nécessaire de changer et ajouter quelques lignes de code :

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netcoreapp3.1</TargetFramework>
    <AzureFunctionsVersion>v2</AzureFunctionsVersion>
  </PropertyGroup>

  <ItemGroup>
    <Compile Include="HelloFunc.fs" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Sdk.Functions" Version="3.0.7" />
  </ItemGroup>

  <ItemGroup>
    <Content Include="host.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Content Include="local.settings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
      <CopyToPublishDirectory>Never</CopyToPublishDirectory>
    </Content>
  </ItemGroup>

</Project>

Après d'avoir changé le contenu de fichier fsproj, on va créer le fichier HelloFunc.fs, puis on va passer l'exemple avec C# à F#. Ici le code C#:

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace FunctionApp1
{
    public static class Function1
    {
        [FunctionName("Function1")]
        public static async Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
            ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");

            string name = req.Query["name"];

            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            dynamic data = JsonConvert.DeserializeObject(requestBody);
            name = name ?? data?.name;

            return name != null
                ? (ActionResult)new OkObjectResult($"Hello, {name}")
                : new BadRequestObjectResult("Please pass a name on the query string or in the request body");
        }
    }
}

Maintenant, on va convertir ça. Ici le code transformé:

namespace HelloDevTo

open System
open Microsoft.AspNetCore.Mvc
open Microsoft.Azure.WebJobs
open Microsoft.Azure.WebJobs.Extensions.Http
open Microsoft.AspNetCore.Http
open Microsoft.Extensions.Logging
open Newtonsoft.Json
open System.IO

module HelloFunction =
    // Define a nullable container to deserialize into.
    [<AllowNullLiteral>]
    type NameContainer() =
        member val Name = "" with get, set

    // For convenience, it's better to have a central place for the literal.
    [<Literal>]
    let Name = "name"

    // Nombre de la funcion
    [<FunctionName("HelloFunction")>]
    // Nivel de Autorizacion para consumir la funcion, la cambiamos a Anonymous ya que para este ejemplo no requerimos nada de seguridad
    // Tambien que metodos HTTP acepta
    // Route nos permite customizar el nombre de salida al publicar la funcion
    let Run([<HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)>] req : HttpRequest, log: ILogger) =
        async {
            log.LogInformation("F# HTTP trigger function processed a request.")

            let nameOpt = 
                if req.Query.ContainsKey(Name) then
                    Some(req.Query.[Name].[0])
                else
                    None

            use stream = new StreamReader(req.Body)
            let! reqBody = stream.ReadToEndAsync() |> Async.AwaitTask

            let data = JsonConvert.DeserializeObject<NameContainer>(reqBody)

            let name =
                match nameOpt with
                | Some n -> n
                | None ->
                   match data with
                   | null -> ""
                   | nc -> nc.Name

            let responseMessage =             
                if (String.IsNullOrWhiteSpace(name)) then
                    "Please pass a name on the query string or in the request body"
                else
                    $"Hello, {name}"

            return OkObjectResult(responseMessage) :> IActionResult
        } |> Async.StartAsTask

Ensuite en utilisant la terminal, on exécute func start --verbose, ça va lancer la fonctionne dans notre environnement local et nous recevrons un lien avec lequel on peut tester, dans mon cas, j'utilisais curl pour y tester.

darkhero> curl http://localhost:7071/api/HelloFunction
Please pass a name on the query string or in the request body
darkhero> curl http://localhost:7071/api/HelloFunction?name=DevTo
Hello, DevTo

Voilà, on a un Azure Fonction qui utilise F# comme langue de programmation. Aussi il est possible de travailler avec Azure Fonction d'une autre manière plus simple, cependant, dans cet article, on verra seulement ce premier essai.

En fin, j’ai fait toutes ses pas pour créer un azure fonction avec F#, tandis que la création d’une avec une autre langue de programmation va être facile puisque celle-ci est plus populaire, par exemple, quand on a installé func et on voit la liste des langues supportés, on peut voir que seulement a templates pour C#, NodeJS, PowerShell et Python, même si on a besoin de travailler avec Golang, F#, Rust ou Deno, nous devons créer nos projets d’une autre façon, étant donné que Microsoft oublie parfois qu’il peut supporter des autres langues de programmation. Pour moi, ça a été amusant puisque j’ai appris beaucoup pendants les recherches.

ZSH & ASDF sur WSL2 Ubuntu

Paul Arizpe — Tue, 30 Mar 2021 21:04:07 +0000

Contexte

Cette histoire commence quand j'ai déçu changer la version PHP 7.4 pour la nouvelle. À la fin de 2019, je réinstallais tout mon ordinateur, ainsi j'essayais installer la version 7.4 de PHP sur WSL Ubuntu, néanmoins, cette version n'étais pas supporter dans les repositories officiels, par conséquent l'unique manière d'y avoir, c'était d'ajouter des repositories externes. Pendant 2020, la communauté PHP grâce aux efforts des développeurs avaient déçu libérer la version anticipé de PHP. J'ai déçu laisser passer puisque celle-ci ne serait pas optime pour mettre en production. Maintenant en 2021, j'ai choisi travailler avec PHP 8, malheureusement quand je voudrai l'installer, je me suis trouvé avec une grand erreur: je ne peux pas installer puisque je travail avec d'autres langues de programmation et ils choquent entre eux, donc je ne peux pas installer la dernière version de PHP, alors j'ai déçu d'effacer tout mon environnement de développe.

(Ré)Installation et requis

Avec de commencer avec l'installation, on doit compter avec les suivantes requis:

Système Opérative de votre préférence: Linux, Windows ou Mac. (Dans mon cas, j'utiliserais Windows avec WSL où j'installais Ubuntu 20.04)
Une connexion Internet puisqu'on va télécharger le logiciel :P

zsh , oh-my-zsh et zinit

Premièrement, on va ouvrir une fenêtre de Terminal, après on va écrire le suivante commande:

(darkhero) > sudo apt update
(darkhero) > sudo apt upgrade
(darkhero) > sudo apt install -y curl git zsh

Pour MacOS, on doit installer Homebrew pour pouvoir installer zsh sur l'ordinateur MacOS

D'après on va installer oh-my-zsh qui va donner des nouveaux fonctionnalités à notre Terminal, pour y installer, on va exécuter:

darkhero> sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Ensuite on va installer les plugins nécessaires en utilisant zinit, pourtant, il est aussi nécessaire d'installer znit:

darkhero> sh -c "$(curl -fsSL https://raw.githubusercontent.com/zdharma/zinit/master/doc/install.sh)"

Après on doit modifier le fichier .zshrc et ajouter à la fin du fichier le suivante code:

zinit light zdharma/fast-syntax-highlighting
zinit light zsh-users/zsh-autosuggestions
zinit light zsh-users/zsh-completions

ASDF & PHP

Pour ajouter asdf dans notre environnement de développe, il est nécessaire d'exécuter:

git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.8.0

# Pour les utilisateurs MacOS, on utilise `brew install asdf`

D'après on ajoute l'asdf au zsh en modifiant le fichier .zshrc, ainsi on en ajoute à la fin:

. $HOME/.asdf/asdf.sh
. $HOME/.asdf/completions/asdf.bash

Maintenant on a asdf et zsh courant sur notre terminal, pourtant, on va installer notre première langue de programmation, ainsi PHP sera l'élu pour cette tache, puisque comment j'avais dit, j'ai besoin d'installer la version 8.

Pour installer PHP, il est nécessaire de chercher le plugin, d'ajouter le plugin et d'installer les requis. Grace au travail de la communauté asdf, c'est facile de trouver le plugin PHP. Néanmoins, il est nécessaire d'installer les requis qui sont:

# Linux Ubuntu/Debian
darkhero> apt-get update && apt-get install -y autoconf bison build-essential curl gettext git libgd-dev libcurl4-openssl-dev libedit-dev libicu-dev libjpeg-dev libmysqlclient-dev libonig-dev libpng-dev libpq-dev libreadline-dev libsqlite3-dev libssl-dev libxml2-dev libzip-dev openssl pkg-config re2c zlib1g-dev

# MacOS
darkhero> brew install autoconf automake bison freetype gd gettext icu4c krb5 libedit libiconv libjpeg libpng libxml2 libzip pkg-config re2c zlib

Si toute se bien installait , il serait temps d'installer PHP en utilisant la commande asdf install <langue de programmation> <version>

darkhero> asdf install php 8.0.3

Une fois que asdf termine d'installer PHP, si on vérifie la version avec php -v, il est possible de voir le message:

darkhero>php-v
No version set for command php
Consider adding one of the following versions in your config file at php 8.0.3

Alors, on doit ajouter au fichier .tool-versions le ligne php 8.0.3 et après si on exécute php -v on peut voir correctement la version PHP.

Le fichier .tool-versions parfois n'a pas été crée, alors nous devons le créer.

PHP 8.0.3 (cli) (built: Mar 29 2021 12:57:13) ( NTS )
Copyright (c) The PHP Group
Zend Engine v4.0.3, Copyright (c) Zend Technologies

Bref, l'installation d'asdf a été bien reçu, étant donné que je travaille avec différents langues de programmation comme Golang, C#/F#, Python, NodeJS, Elixir, etc. Toutefois, j'installe chaque langue de programmation individuellement, par conséquent je trouve des problèmes pendant tout le processus, néanmoins, asdf permets gérer toutes les langues et leurs versions, ainsi c'est facile de tester les nouvelles versions sans modifier votre environnement de développe. Finalement, je vous laisse la vidéo où je fais toutes les pas de cet article.

> echo "Hello Dev.to"

Paul Arizpe — Mon, 22 Jun 2020 20:46:50 +0000

Premièrement, celui-ci est mon premier article sur la plateforme Dev.to. Avant j'avais écrit sur jeux vidéos mais après je décide écrire sur la programmation dans la plateforme de Medium dont parfois j'écrit. J'ai profité écrire des jeux vidéos longtemps parce que je les aimes.

Après de cette petite introduction, je m'appelle Paul Arizpe mais tout le monde me connais comment "Kira Mishima"(mon nom d'utilisateur de Github ). J'ai étudié à l'université de Puebla après j'ai pris différents cours pour mettre à jour mes connaissances. Je suis Backend Développeur donc j'utilise principalement les langues de programmation PHP , C# , Golang , NodeJS et parfois Python, F# et Elixir. Parfois je program le frontend en utilisant Angular X ou Vue. Il est rare que je fasse le rôle de DevOps dans lequel j'utilise Ansible, AWS CLI, Azure CLI et Bash.

De temps en temps je participe aux Hackathons avec amis et amies dont on y utilise nos connaissances de programmation. Sous le prétexte d'aller manger pizza, je les amène aux évènements. Ainsi je suis le gars qui a changé un Backend complet fait en Java à Golang en 3hrs dans un Hackathon.

Maintenant j'étude à l'Alliance Française au Mexique donc un jour après du confinement, j'aimerais travailler en France ou Canada. Parfois j'ai fait de directs sur Twitch et FB Gaming où j'enseigne les choses que j'ai appris. Finalement je vous remercie pour lire cette petite introduction et j'espèrerait écrire le plus tôt possible.