lkdjiin

Xavier Nayrac

Mes premiers pas avec Arduino

| Comments

Niveau : facile

Ça faisait un ou deux ans que l’envie me titillait. Jouer avec Arduino, Raspberry Pi, etc. Mais essentiellement par manque de temps, je n’avais pas encore franchi le pas. Et puis dernièrement, on m’a offert le Starter Kit Arduino. Plus de faux pretextes, je devais m’y mettre ;)

Mieux utiliser le programme gem

| Comments

Niveau : facile

Le programme gem est bien connu des rubyistes, et ce pour une bonne raison: il est au coeur de l’utilisation de Ruby. Si je veux par exemple profiter de awesome_print dans ma console irb, je vais l’installer grâce à gem:

$ gem install awesome_print

De même, avez-vous déjà vu une appli Rails se passer d’un Gemfile ?

Gemfile
1
2
3
4
5
6
source 'https://rubygems.org'
ruby '2.0.0'

gem 'rails', '4.0.0'
gem 'pg'
...

En fait, si vous avez fait seulement 3 jours de Ruby dans votre vie, vous savez utiliser gem. Mais l’utilisez-vous à fond ? Moi, non. Enfin pas encore.

To tap or not to tap en Ruby ? C’est la question

| Comments

Niveau : facile

Le monde des Rubyistes est divisé en deux: ceux qui utilisent Object#tap à tout propos, et ceux qui ne connaissent pas cette méthode. Dans l’article Five Ruby Methods You Should Be Using sur le blog d’Engine Yard, Ben Lewis nous parle justement, entre autre, de Object#tap en expliquant très bien son mécanisme.

Mon article d’aujourd’hui sera lui aussi divisé en deux, d’abord une traduction en français de l’article original de Ben Lewis sur Object#tap, puis une critique (que j’espère constructive) à la fois de l’article et de la méthode tap

Le jeu de la vie en Rust - partie 2

| Comments

Niveau : facile

Tests unitaires avec Rust

Je vais ajouter des tests unitaires au code du dernier article. Il s’agissait simplement d’une seule fonction pour créer une génération aléatoire de cellule. Voici tout le code, l’implémentation et les tests dans le même fichier src/main.rs.

src/main.rs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
use std::rand::Rng;

#[cfg(not(test))]
fn main() {
    let gen = create_generation(3, 4);
    println!("{}", gen);
}

fn create_generation(width: uint, height: uint) -> Vec<uint> {
    let size = width * height;
    let mut result = Vec::new();
    for _ in range(0u, size) {
        let cell = std::rand::task_rng().gen_range(0u, 2u);
        result.push(cell);
    }
    result
}

#[cfg(test)]
mod tests {
    use super::create_generation;

    #[test]
    fn test_create_generation_length() {
        let result = create_generation(4, 3);
        assert_eq!(12, result.len());
    }

    #[test]
    fn test_create_generation_has_1_and_0() {
        let gen = create_generation(2, 3);
        for i in range(0u, gen.len()) {
            assert!(gen[i] < 2);
        }
    }
}

Le jeu de la vie en Rust - partie 1

| Comments

Niveau : facile

Premiers pas avec Rust

On va écrire une version simple du jeu de la vie en Rust.

Installer Rust

Rendez-vous sur cette page pour trouver le type d’installation qui vous convient. Même si on peut trouver que cela pose des problèmes, j’ai opté pour la méthode la plus simple:

$ curl -s https://static.rust-lang.org/rustup.sh | sudo sh

Cela installe la version nightly et le gestionnaire de paquet Cargo. L’installation est très rapide.

Pour information, voici la version que j’ai installé:

$ rustc --version
rustc 0.13.0-nightly (636663172 2014-12-28 16:21:58 +0000)

Le jeu de la vie en Haskell - partie 4

| Comments

Niveau : facile

Je dois maintenant pouvoir extraire 9 cellules d’une génération (la cellule cible et ses 8 voisines). Pour cela, je vais avoir besoin de la fonction suivante:

1
extractNeighborhood :: Generation -> Int -> Int -> [Cell]

Elle prendra en entrée la génération, l’index de la rangée et l’index de la colonne. Mais pour simplifier l’implémentation de extractNeighborhood j’ai ressenti le besoin d’une fonction utilitaire sliceAround qui ferait ça:

$ ghci
> :load Slice.hs 
> let list = [0,1,2,3,4,5]
> sliceAround 1 list
[0,1,2]
> sliceAround 4 list
[3,4,5]
> sliceAround 0 list
[0,1]
> sliceAround 5 list
[4,5]

Le jeu de la vie en Haskell - partie 3

| Comments

Niveau : facile

Cette fois je met des tests en place avec HUnit. Pour cela, je dois d’abord modulariser mon code. J’ai donc déplacé le code de la dernière fois, sans la fonction main, dans un fichier GameOfLife. Puis j’ai ajouté la déclaration du module.

Le jeu de la vie en Haskell - partie 2

| Comments

Niveau : facile

Je vais commencer par une amélioration du code du dernier article (merci @julienXX pour les indices).

La fonction createGeneration était comme ceci:

1
2
3
4
5
createGeneration :: [Int] -> Int -> [[Int]] -> [[Int]]
createGeneration [] width generation = generation
createGeneration cells width generation =
    let line = take width cells
     in createGeneration (drop width cells) width (line:generation)

Je l’ai transformé comme cela:

1
2
3
4
5
6
type Cell = Int

createGeneration :: Int -> [Cell] -> [[Cell]]
createGeneration _ [] = []
createGeneration width cells = line:(createGeneration width rest)
  where (line, rest) = splitAt width cells

Le jeu de la vie en Haskell - partie 1

| Comments

Niveau : facile

Première rencontre avec Haskell

L’histoire qui suit a du arriver à de nombreux développeurs rencontrant Haskell pour la première fois.

— Bon, comment produire un nombre aléatoire ?
— Ah OK, je vois.
— Euh, attends, tu veux dire que je dois passer un générateur avec une seed à chaque fois ?
— Ah OK, c’est l’histoire des fonctions pures, quand tu as le même argument en entrée, tu produis toujours la même valeur en sortie. Du coup, tu ne peux pas avoir une fonction random qui te sortirait une valeur différente à chaque appel. Oui, d’accord, c’est logique.
— Ah mais non, attends, je fais comment pour lui donner une seed différente à chaque lancement du programme ? Ah, bin oui, j’ai qu’a prendre l’heure système, ou un truc comme ça.
— Comment ça le générateur n’accepte pas mon heure système comme seed !? — Comment ça c’est pas le bon type ?! Qu’est-ce que c’est que cette histoire de monade IO ? Qu’est-ce que c’est que ce langage où je ne peux pas convertir l’heure système en un entier qui me servirait à quelque chose ???!!!

Bref, bonjour Haskell…