Mises à jour de octobre, 2010 Activer/désactiver les fils de commentaires | Raccourcis clavier

  • Quentin 22:28 le 27 October 2010 Permalien | Réponse
    Tags :   

    Je viens juste de réaliser que la PDC 20… 

    Je viens juste de réaliser que la PDC 2010 allait commencer dans quelques heures maintenant. Je suis en ce moment même en train de regarder une des sessions de l’année passée sur le langage de modélisation M.

    J’en profite donc pour donner mes centres d’intérêts pour cette année :

    1. Fsharp
    2. Langage M / Oslo (je ne suis pas sûr qu’ils en parlent)
    3. Windows Phone 7

    Si je fais comme l’année dernière, je vais surement regarder des dizaines de sessions plus intéressantes les unes que les autres. Et moi qui me plains toujours de ne pas avoir assez de temps, je dois le faire exprès.

    Pour ceux qui voudraient retrouver des vidéos des sessions 2009, vous y aurez accès sur le site de la PDC ici.

    Publicités
     
  • Quentin 19:10 le 12 October 2010 Permalien | Réponse
    Tags :   

    Autotest – une solution 

    Je suis un grand fan de TDD et j’aime voir rapidement si mes tests passent (ou pas).

    J’ai découvert AutoTest il y a quelques années, quand je m’intéressais au Ruby. Il s’agit d’un outils qui va exécuter vos tests automatiquement, ce qui vous permet de savoir directement si le test est validé.

    Des outils comparables existent en .Net. J’ai passé la semaine dernière à essayer de les faire fonctionner, sans grand succès. J’ai donc essayer de voir si je pouvais utiliser AutoTest directement pour exécuter mes tests en .Net. A la place, je me suis rabattu vers Watchr, un gem ruby qui permet d’exécuter des scripts quand un fichier à été sauvegardé.

    Vous aurez donc droit dans quelques jours à une solution qui fonctionne. En attendant, vous pouvez toujours découvrir Watchr sur GitHub.

     
  • Quentin 19:44 le 2 October 2010 Permalien | Réponse
    Tags : fsharp   

    FSharp et le pattern matching 

    Je m’intéresse un peu à la programmation fonctionnelle en ce moment et une des fonctionnalités que je trouve très intéressante est le pattern matching.

    Pour faire comprendre l’intérêt, prenons un exemple classique : la fonction Factorielle.

    Exemple de Pattern matching

    En C # :

    public class Factorielle
    {
        public static int fact(int n)
        {
            if (n == 0)
            {
                return 1;
            }
            else
            {
                return n*fact(n - 1);
            }
        }
    }
    

    En F# :

    let rec fact n =
        match n with
        | 0 -> 1
        | _ -> n * fact(n-1)
    

    ou encore plus court :

    let rec fact = function
        | 0 -> 1
        | x -> x * fact(x-1)
    

    Pour commencer, un avantage de F# est de n’avoir besoin de définir que la fonction.
    En C#, rien que pour la fonction factorielle, on doit :

    • créer une classe,
    • définir la déclaration de la fonction,
    • préciser qu’elle est public …

    Si on regarde bien, on voit aussi qu’on ajoute beaucoup de parenthèses et d’accolades pour pas grand-chose. En théorie, si le code est bien écrit, les accolades ne devraient servir à rien. On devrait pouvoir facilement voir où sont les blocs de code.

    En gros, on se retrouve avec un code plein de bruit.

    Pourtant, tout ce qui est important dans la fonction factorielle, c’est qu’en lui transmettant 0, on veut comme résultat 1 et pour les autres cas, on veut n * fact(n-1).

    En F#, on se concentre sur l’essentiel.

    Pattern matching sur une liste

    Pour continuer sur le pattern matching, on va créer une fonction qui va faire la somme des éléments d’une liste.

    Pour implémenter ça, on a deux cas à prendre en compte : une liste vide et les autres cas. Pour la liste vide, on renvoi 0 et dans les autres cas, on retourne la somme de la tête de la liste et la somme du reste de la liste.

    // xs est la liste à additionner.
    let rec sum xs =
        match xs with
        | [] -> 0
        | head::tail -> head + sum tail
    

    Dans ce cas, on créer un pattern head::tail et F# va de débrouiller pour extraire les données de la liste suivant la définition de la fonction cons : (::) -> a -> [a] -> [a]; ce qui ce traduirait par une fonction générique en C#, List<T> operator ::(this T el, List<T> xs).

    Pour bien comprendre ça, on peut voir comment construire un liste de plusieurs façons :

    [1..5]
    = [1,2,3,4,5]
    = 1 :: [2,3,4,5]
    = 1 :: 2 :: [3,4,5]
    ...
    1 :: 2 :: 3 :: 4 :: 5 :: []
    

    Toutes les syntaxes ci-dessus sont équivalentes. Dans la ligne 6, on utilise l’opérateur cons (::) pour créer une liste en ajoutant des éléments à la liste vide. Si on donne la liste [1,2,3,4,5] à la fonction sum, celle-ci va décomposer la liste en suivant le principe inverse.

    Pattern matching sur plusieurs arguments

    C’est la partie du pattern matching que je trouve la plus intéressante. On peut facilement prendre en compte plusieurs arguments pour le pattern.

    let mafonction a b =
        match a,b with
        | _,0 -> 0
        | 0,_ -> 0
        | _ -> a + b;;
    

    Même si le code produit en fsharp est plus consit et expréssif qu’en C#, j’aurai aimé avoir une syntaxe comme en Haskell. En prenant pour exemple la fonction factorielle :

    fact 0 = 1
    fact n = n * fact(n-1)
    

    Pour finir, je vous conseille le site Wikibooks > F Sharp Programming pour en apprendre plus sur le langage. Vous trouverez plus d’information sur F# en général mais aussi sur le pattern matching.

     
  • Quentin 19:18 le 1 October 2010 Permalien | Réponse  

    Hello world! 

    Hello World !

    Source : Wikipedia

    WordPress a décidé de nommer mon premier article Hello World! et je pense que le nom est bien choisi.

    Je vais donc essayer de me présenter :

    Je m’appelle Quentin Proust, je suis des études d’ingénieur en informatique et je passe le plus clair de mon temps à expérimenter sur des technologies ou des concepts.

    Je suis plutôt orienté technologie Microsoft et j’ai été accepté en tant que MSP cette année.

    Hello World !

    C’est un nom qui est bien choisi. Dans ce blog, je vais surtout parler des découvertes que je fais dans mes expériences quotidiennes avec des logiciels, des langages et des notions de développement.

    Voilà dans les grandes lignes ! See you soon.

     
c
créer un nouvel article
j
message/commentaire suivant
k
message/commentaire précédent
r
Réponse
e
Modifier
o
afficher/masquer les commentaires
t
remonter
l
connexion
h
afficher/masquer l'aide
shift + esc
Annuler
%d blogueurs aiment cette page :