In my Mind

{ }

recherche

Aller au contenu | Aller au menu | Aller à la recherche

Sexe : identité et égalité

Un petit billet bookmark pour vous conseiller de lire cet article de David Madore qui traite de la part du sexe dans l'identité publique et de la notion d'égalité dans la loi (par rapport au sexe mais peut-être étendu à n'importe quel critère).

Debian Tips #1: Find missing recommended packages

aptitude has a very advanced search system which allows you to look for anything you may want.

Here is how to find missing recommended packages:

  1. # Explanation: we are looking for broken reverse dependencies
  2. # of type “recommends” for installed packages.
  3. aptitude search '~RBrecommends:~i'

To install them (and mark them as installed automatically):

  1. aptitude install '~RBrecommends:~i'+M

Documentation.

POSIX-compliant detection of the shell's features

If you want to write a shell script or “library”, you may want to test whether the current shell has a given feature or not, for instance for performance concerns.

For instance, if you want to check if a string matches a regular expression and have your script works in a POSIX shell, you will use an external program such has “grep”, “sed” or whatever, which is costly and useless if your script is in fact running in Bash or Zsh which built in support for regular expression matching.

  1. # The POSIX way:
  2. if printf '%s' "$string" | grep --regexp-extended --quiet --regexp="$regexp"
  3. then
  4. # Do what you want.
  5. fi
  6.  
  7. # The Bash way:
  8. if [[ $string =~ $regexp ]]
  9. then
  10. # Do what you want.
  11. fi

A solution to this problem is to define a function for matching a string against a regular expression which will use the built in support if available otherwise the external program.

But how to detect whether a feature is supported or not?

The answer is not difficult but not obvious either.

First, you have to know that, when the shell meet a invalid syntax, it stops the parsing, displays an error message and returns a value different than 0. It does so also with the eval command which can be put in a subshell to contain the parsing error and to prevent it from stopping our script.

  1. code='echo ${string:0:10}'
  2.  
  3. if (eval "$code") 2> /dev/null
  4. then
  5. echo 'Impossible to extract a substring in this shell!' >&2
  6. exit 1
  7. fi

But, because when eval succeeds it returns the return value of the code evaluated, you may use codes which return 0.

To encapsulate this trick, I propose you the following function:

  1. # Checks whether this shell has a given features (variable substitutions, …).
  2. #
  3. # The code passed must be assignable to a variable, so you must use command
  4. # substitution if you want to test a command.
  5. #
  6. # have_feature CODE
  7. have_feature()
  8. {
  9. (eval __have_feature="$1") > /dev/null 2>&1
  10. }

Here are some use cases:

  1. if have_feature '${#VAR}'
  2. then
  3. echo This shell has the length variable substitution.
  4. fi
  5.  
  6. if have_feature '$([[ word =~ . ]])'
  7. then
  8. echo This shell has built in regular expression support.
  9. fi

As usual, this function is defined in my shell library jfsh and if you want to see which features as your shell you may be interested in shell-info.

If you have any questions or remarks, please, let me a comment.

Split a string by character(s) in POSIX shell

Often, when someone needs to split a given string by a character in a shell script, he uses the “cut” command.

Example:

  1. string='first item,second,third'
  2.  
  3. first="$(echo "$string" | cut -d ',' -f 1)"
  4. second="$(echo "$string" | cut -d ',' -f 2)"
  5. third="$(echo "$string" | cut -d ',' -f 3)"

But, as you can see, this is verbose and not very efficient because six external programs are executed (3 echos + 3 cuts, even if commonly echo is built in in the shell). And cut can only handle a single character for delimiter, if you want to split on “:” and “,” for instance, you have to use cut multiple times or to use another program such as “awk” or “sed”.

Fortunately, there is one easy and efficient alternative in the POSIX shell specification : to use the “Input Field Separators” (IFS for the intimates) variable and the shell field splitting in conjunction with the read command and the here-document syntax:

  1. string='first item,second,third'
  2.  
  3. IFS=',' read -r first second third <<EOF
  4. $string
  5. EOF
  6.  
  7. // Works even with multiple delimiters!
  8. string="first,second:third"
  9.  
  10. IFS=',:' read -r first second third <<EOF
  11. $string
  12. EOF

If you think that the syntax is a bit messy, nothing prevents you from writing a small wrapper:

  1. # split STRING DELIMITERS VAR_NAME...
  2. split()
  3. {
  4. local string IFS
  5.  
  6. string="$1"
  7. IFS="$2"
  8. shift 2
  9. read -r -- "$@" <<EOF
  10. $string
  11. EOF
  12. }
  13.  
  14. string='first,second:third'
  15. split "$string" ',:' first second third

Yes, that's neat. But there are some things you should be aware of.

First, you must be conscious that the read command splits the fields for all but the last variable: this one will contain the rest of the string. So if you don't need it, you must add a variable which will contain the rest of it:

  1. string='first item,second one,third one,fourth one'
  2.  
  3. // We wants only the two first items.
  4.  
  5. split "$string" ',' item1 item2
  6. // The problem is that “item2” contains “second one,third one,fourth one”.
  7.  
  8. // We must provide an additional variable.
  9. split "$string" ',' item1 item2 garbage

The other problem is worst because I have no solution for it, if you use space as delimiter, the shell will discard any empty fields:

  1. split 'foo,,bar,baz' ',' first second third fourth
  2. // first → “foo”
  3. // second → “”
  4. // third → “bar”
  5. // fourth → “baz”
  6.  
  7. split 'foo bar baz' ' ' first second third fourth
  8. // first → “foo”
  9. // second → “bar”
  10. // third → “baz”
  11. // fourth → “”

As usual the split function is implemented in my small shell library jfsh.

Programmation par contrat en C/C++

En programmation, on est souvent confronter à un choix :

  1. faire beaucoup de vérifications, ce qui améliore la robustesse du code (quand une erreur se produit, on est capable de la situer assez rapidement) mais rend le code plus volumineux et plus lent (parfois beaucoup plus) ;
  2. ne faire aucune vérification et supposer que notre code est correct et que les personnes qui l'utiliseront le feront correctement.

La réponse de la plupart des langages (dont C et C++ avec l'en-tête standard « assert.h » pour le C et « cassert » pour le C++) à ce problème sont les assertions.

Les assertions sont des conditions qui se doivent d'être toujours vérifiées si le code est correct. Le vrai avantage de ces assertions c'est qu'une fois que le code a été bien testé et qu'il est considéré comme sûr, elles peuvent être désactivées et ne ralentissent donc plus l'exécution.

Exemple d'assertion dans un code C (C99, donc avec les booléens ;)) :

  1. void foo(bool bar)
  2. {
  3. if (bar)
  4. {
  5. ...
  6. return;
  7. }
  8.  
  9. // On sait que bar est faut car s'il avait vrai on serrait sorti à cause du
  10. // « return » ci-dessus, mais si le code avait été compliqué, en aurions
  11. // nous été aussi sûr ?
  12. // Dans ce ce cas, n'est-il pas mieux d'en être sûr avec une assertion ?
  13. assert(!bar);
  14. ...
  15. }

On peut aussi utiliser les assertions pour vérifier que l'exécution d'une fonction se fait bien dans les conditions requises (les pré-conditions) et qu'elle fasse bien ce qu'elle doit (les post-conditions).

Exemple :

  1. /**
  2.  * Calcule le logarithme népérien de “x”.
  3.  *
  4.  * Pré-condition : x doit être strictement positif.
  5.  */
  6. double log(double x)
  7. {
  8. assert(x > 0); // Vérification de la pré-condition
  9.  
  10. double result;
  11. ... // Calcul
  12.  
  13. assert(exp(result) == x); // Vérification de la post-condition
  14. return result;
  15. }

Et voilà, sans vraiment s'en rendre compte, on a fait de la programmation par contrat : dans la pré-condition on a vérifié que l'utilisateur de la fonction respecte le contrat d'utilisation et dans la post-condition on a vérifié que la fonction respecte bien son engagement (ici, calculer le logarithme népérien).

Maintenant, nous allons, à l'aide de macros, essayer d'un peu plus formaliser cela.

À l'aide du code ci-dessous, on va créer les alias « ensures » et « requires » à « assert » qui vont respectivement symboliser les pré-conditions et les post-conditions.

  1. #define requires(expression) assert(expression)
  2. #define ensures(expression) assert(expression)

Notre fonction log ressemble maintenant à ça :

  1. /**
  2.  * Calcule le logarithme népérien de “x”.
  3.  *
  4.  * Pré-condition : x doit être strictement positif.
  5.  */
  6. double log(double x)
  7. {
  8. requires(x > 0);
  9.  
  10. double result;
  11. ... // Calcul
  12.  
  13. ensures(exp(result) == x);
  14. return result;
  15. }

Vous voyez bien que ça n'était pas difficile de trouver nos pré- et post-conditions, mais il faut bien reconnaître que la fonction « log » n'est pas un modèle de complexité. Dans le cas d'une fonction complexe, comment s'assurer que nos conditions sont correctes ?

Il n'y a pas 36 solutions : il faut les tester.

Le problème c'est que la macro « assert » fournie n'est pas très pratique pour écrire des jeux de tests. En effet, si l'on teste que nos pré-conditions bloquent bien les cas incorrects, la macro « assert » arrêtera tout simplement le programme et nous empêchera de continuer les tests.

Une des solutions possibles est de passer en C++ et d'utiliser les exceptions pour faire en sorte que si nos conditions ne sont pas respectées, le programme ne s'interrompe pas mais génère une erreur récupérable.

Appelons notre type d'exception « ContractViolated » et regardons ce que pourrait donner un test de la pré-condition de notre fonction « log » :

  1. try
  2. {
  3. log(-1);
  4.  
  5. exit(EXIT_FAILURE); // Aucune exception n'a été levée.
  6. }
  7. catch (ContractViolated)
  8. {} // Ok, tout est bon.
  9. catch (...)
  10. {
  11. exit(EXIT_FAILURE); // Le mauvais type d'exception a été levé.
  12. }

Bon, comme c'est pas très sympa a écrire et que je suis sympa, je vous propose d'utiliser la macro « assert_exception » qui est disponible dans mon fichier d'en-tête C/C++ destinée à faire de la programmation par contrat contracts.h.

On peut donc maintenant écrire un jeu de test :

  1. // Vérification de la pré-condition.
  2. assert_exception(log(-1), ContractViolated);
  3. assert_exception(log(0), ContractViolated);
  4.  
  5. // Vérification de la post-condition.
  6. assert(log(exp(1)) == 1);

Alors, ça se fait non ? Vous n'avez donc plus d'excuse pour ne pas faire de la programmation par contrat et écrire des jeux de tests.

Encore une petite chose, il y a un type de contrats que nous n'avons pas vu : les invariants de classes. Ça concerne surtout le C++, mais si vous faites de la programmation orienté objet en C, vous pouvez adapter le raisonnement.

Le principe est le suivant : pour la plupart des classes, il y a des conditions que ses instances se doivent de toujours vérifier, ce sont les invariants de classe.

On peut prendre comme exemple une classe « Voiture » dans laquelle on peut ajouter ou retirer des passagers. Mais le nombre de passagers de la voiture doit toujours être positif :

  1. class Voiture
  2. {
  3. public:
  4. void ajouter_passager();
  5. void retirer_passager();
  6.  
  7. private:
  8. /**
  9. * Le nombre de passager.
  10. *
  11. * Invariant : doit être strictement positif.
  12. */
  13. int nb_passagers;
  14. };

Afin de vérifier les invariants, je propose de rajouter une méthode « isValid() » qui se charge de vérifier si les invariants sont respectés.

  1. bool Voiture::isValid() const
  2. {
  3. return (nb_passagers > 0);
  4. }

Cette méthode devra être appelé à la fin de toutes les méthodes non-constantes de la classe (y compris les constructeurs) comme argument « ensures », car c'est bel et bien une post-condition déguisé. Pour plus de simplicité, je vous propose la macro « validate » qui s'utilise de cette façon :

  1. validate(*this);

Voilà, c'est tout pour le moment, si vous avez des questions/suggestions, n'hésitez pas, sinon, je vous conseille de regarder contracts.h qui est assez bien expliqué et les jeux de tests de ma bibliothèque C++ pour plus d'exemples.

Pseudo-arrays for POSIX shell

Hi everyone,

I recently wrote a script and I needed to use arrays.

Unfortunately, there are no arrays in the POSIX shell specification. But, after some research I found a way to use pseudo-arrays.

The first trick is to use the set command which permits to modify the values of the positional parameters. You will therefor be able to get the number of elements ($#), access any items (for the n-th item: $n) or iterate through them. The only thing I don't know is how to change the value of one of them.

The second trick is to properly quote the various elements you want to put in it. To do that I wrote a small function (which I won't describe here) which is able substitute a substring by another one in a string. I used this function to replace each occurrence of a single quote by “a single quote + an escaped single quote + a single quote” in my items and I enclosed them between two single quotes.

Here is an example of how using it.

  1. #!/bin/sh
  2.  
  3. . jfsh.sh # Contains the quote function (and subst which is used by it)
  4.  
  5. print_arrays()
  6. {
  7. local array entry
  8.  
  9. for array
  10. do
  11. eval "set -- $array" # Loads the array contained in $1
  12.  
  13. printf '%d elements\n' $#
  14. for entry
  15. do
  16. printf ' “%s”\n' "$entry"
  17. done
  18. done
  19. }
  20.  
  21. reverse_array()
  22. {
  23. local entry result
  24.  
  25. eval "set -- $1"
  26.  
  27. for entry
  28. do
  29. result="$(quote "$entry") $result"
  30. done
  31.  
  32. printf '%s\n' "$result"
  33. }
  34.  
  35. array1="$(quote 1 "second element" "third one")"
  36.  
  37. # This array will contains the filenames of every files in this directory.
  38. array2="$(quote *)"
  39.  
  40. # We can apply a function on array1.
  41. array3="$(reverse_array "$array1")"
  42.  
  43. # Let's print the various arrays.
  44. print_arrays "$array1" "$array2" "$array3"

The file “jfsh.sh” is available on github.

Jon Lajoie − « Everyday Normal Guy »

Un ami m'a récemment fais découvrir une vidéo (Show me Your Genitals) de Jon Lajoie, un comédien étatsunien qui fait des clips qu'il poste sur Youtube.

J'ai beaucoup aimé ce côté décalé et j'ai regardé ses autres créations. Je suis tombé sur Everyday Normal Guy qui m'a encore plus plu que la première, je vous propose donc de la visionner.


Everyday Normal Guy

Lire la suite

Hommage à John Williams

Voici une vidéo sur laquelle je suis tomber sur le net, je la trouve absolument fantastique. Il s'agit d'un utilisateur de YouTube, ApprenticeA, qui a réalisé une chanson sur le thème de La Guerre des étoiles sur différents airs composés par John Williams, fameux compositeur de musiques de film.

Regardez moi ce talent.


Star Wars - Un hommage a capella à John Williams

Personnellement, je les ai tous reconnus (mais j'ai eu du mal avec Les Dents de la mer).

Les paroles sont dans la suite de ce billet.

Lire la suite

Amélioration du panneau latéral en vue pour Nautilus

Depuis quelques temps (je dirais un an environ) j'ai l'impression que les choses bougent bien du côté de GNOME, autant du côté technique que du côté utilisateur.

Nouvel exemple de ce mouvement, une maquette du panneau latéral de Nautilus a été réalisé par Hylke.

Nautilus - Sidebar mockup

On ne peut nier qu'il y quand même du progrès. Et encore, normalement devrait être ajouter la possibilité de réduire (avec les classiques + et -) les différentes sections. J'espère que ça sera disponible pour GNOME 2.26 (sortie prévu pour mars 2009).

Cloverfield

Aujourd'hui, je me suis regardé les épisodes 10 et 11 de la saison 12 de South Park (je les conseille d'ailleurs, ayant ri du début à la fin). Ces épisodes (surtout le dernier en fait) font clairement référence au film fantastique Cloverfield et m'ont donné envie de m'y replonger.

Cloverfield

Cloverfield est un film de monstre produit par J. J. Abrams (créateur d'Alias, Lost, …). Il a la particularité d'être entièrement filmé en vue subjective ou plus précisément par un caméscope (tout comme Le Projet Blair Witch ou [●REC]) tenu en permanence par un des personnages, ce qui renforce l'immersion du spectateur (ça et les effets spéciaux incroyablement réalistes) et lui fait partager la folie de ce que vivent les personnages.

Encore plus fort : le film tout entier n'est qu'un enregistrement provenant de cette caméra, ce qui, dans l'esprit du spectateur, fait passer le film de l'état de fiction à celui de témoignage. On en vient à se demander comment on réagirait dans une situation pareille, il est vraisemblablement impossible qu'un tel scénario se produise mais qui sait ?

C'est bien le propre de ce genre − les films de monstres, nous faire douter de ce que l'on croit possible. D'autant plus que, pour la petite histoire, J. J. Abrams aurait eu l'idée de ce film à cause du Bloop, un son à très basse fréquence qui a été détecté à plusieurs reprises par le National Oceanic and Atmospheric Administration durant l'été 1997 dans l'océan Pacifique, l'origine de ce son est encore inconnue.

Ce qui fait aussi la spécificité de Cloverfield, c'est le buzz qui a été mis en place autour par Abrams avant sa sortie. Pour cela, je vous propose d'aller voir un très bon récapitulatif sur ce billet et des vidéos sur cette page.

En tous cas, j'attends avec impatience la suite : Aladygma.

FDLS 3 - Hellboy II : Les légions d'or maudites

Cette semaine, c'est Hellboy II que j'ai vu sur grand écran. Loin du charme du petit film français de la semaine dernière, cette fois ci c'est effets spéciaux et bastons à gogo.

Un petit synopsis pour commencer ?
Il y a des siècles de ça, les hommes et les créatures fantastiques (elfes, gobelins, etc.) se partageaient la Terre. Les hommes, aveuglés par leur soif de pouvoir, cherchèrent à détruire les autres. Pour se protéger, les gobelins construisirent une armée de soldats mécaniques indestructibles (en or, d'où le titre) et donnèrent au roi des elfes le moyen de la contrôler : une couronne. Cette armée massacra les humains, et, le roi elfe, prit de remords, leur proposa une trêve et la couronne fut brisée en trois parties : une confiée au humains, les deux autres gardées par les elfes. Mais, le prince elfe n'est pas satisfait de ce pacte et reviendra pour se venger et réveiller les légions d'or maudites. Ce qu'il décide justement de faire à notre époque au début du film.

Hellboy - The Golden Army

Tout d'abord, je tiens à préciser que je n'ai pas vu le premier film donc je n'ai peut-être pas toutes les cartes pour juger. Malgré une débauche d'effets spéciaux (c'est dingue ce qu'ils font maintenant, plus de différence avec le réel) et de combats de tous genres (mains nues, sabres, lances et pistolets), ce film propose des moments plus calmes, plus poétiques.

C'est un film difficile à juger, d'autant plus que ce n'est pas vraiment un genre de films que j'ai l'habitude de voir, il n'est pas extraordinaire, mais pas si mal que ça non plus, il allie les caractéristique d'un film d'action pour adulte et celles d'un film fantastique pour enfants, donc je dirais juste que vous pouvez aller le voir si vous êtes fan de belles images, d'action où de film de Guillermo del Toro, sinon, passez votre chemin.

J'ai parfaitement conscience que mon analyse n'est pas claire et mal construite, mais les souvenirs du film me glissent déjà entre les doigts, donc il m'est impossible de faire mieux, pardonnez moi ;).

Immatriculation et bêtise - « Je vous ai compris. »

Notre très cher ministère de l'Intérieur a bien entendu les doléances des attachés-au-numéro-de-département, tel que le collectif Jamais sans mon département : la présence du numéro de département restera obligatoire sur les prochaines plaques d'immatriculation !

Cependant, ce numéro n'aura plus vraiment de signification puisque le propriétaire du véhicule pourra choisir le département avec lequel il ressent les attaches les plus fortes.

Futures plaques d'immatriculation

En conclusion, ce numéro ne sert plus à grand chose, mais reste obligatoire afin de contenter tout le monde.

Qui a dit manipulation ?

En vrac

  • L'économie des idées, un bref mais intéressant billet qui explique pourquoi les raisonnement de l'économie classique (sur du matériel) ne peut s'appliquer à l'informatique et à la connaissance en général (immatériel).
  • Si vous aimez la musique, la découverte et que le podcasting ça vous branche, je vous conseille le site SoundNation (via DumpsterDriver).
  • Pour la musique classique, un petit tour sur ce billet (ça date un peu, mais c'est pas mal).
  • Connaissez-vous le blog culinaire de Georgette ? Parce qu'il vaut le détour, vraiment. Il allie superbes photos, appétissantes recettes, biographie et sarcasmes. J'aimerais bien savoir qui est l'auteur de ce blog… (Merci Manon pour ce lien.)
  • Un petit tour de toboggan ça vous tente ?

Publicité BarclayCard

En manque d'idées pour Halloween ?

Je vous suggère de visiter ce site qui vous donnera tout plein d'idées marrantes.

Et voici une vidéo de présentation du film sur DVD du site Hallowindow.com que je trouve assez fun, mon moment préféré est à 1:00 ;). 'tain, j'imagine les gamins traumatisés devant :p.


Présentation du DVD de Hallowindow.com

Aquarium de Camille Saint-Saëns

Voici une des compositions les plus ensorceleuse (selon moi et ma maigre connaissance en ce domaine) de la musique classique française, Aquarium de Camille Saint-Saëns extrait de son œuvre Le carnaval des animaux.


L'Aquarium - Camille Saint-Saëns

La fille de l'Est d'Arthur H

J'ai envie de vous faire découvrir une chanson d'Arthur H, La fille de l'Est, de l'album Adieu tristesse.


La fille de l'Est - Arthur H

Comme d'hab', les paroles sont dans la suite du billet.

Lire la suite

L'humour selon 4chan

4chan - Lisa is angry

C'est un brin particulier, mais moi j'aime bien.

Comprend qui peut…

FDLS 2 - Le crime est notre affaire

Bienvenue dans cette deuxième édition (première officiellement) du Film De La Semaine.

Cette semaine c'est d'une comédie policière dont je vais parler, il s'agit de Le crime est notre affaire adapté du roman éponyme d'Agatha Christie.

Cette comédie légère, menée par un duo plein de malice (André Dussollier et Catherine Frot), dans une ambiance à mi-chemin entre une pièce de théatre et un cluedo grandeur nature, emmène le spectateur dans son univers chaleureusement vieillot et l'invite à mener l'enquête aux côtés de Prudence Beresford afin de découvrir toute la vérité sur cette femme aux gants rouges qui aurait, selon tante Babette, été étranglée dans un train.

Ce n'est ni le film du siècle, ni celui de l'année, mais il ne prétend pas l'être et n'a comme vocation que de faire passer un bon moment aux spectateurs, mission qu'il remplit très bien.

Le crime est notre affaire

Personnaliser l'ajout et la suppression de comptes

Il est aisé sous Debian de créer et de supprimer des comptes (locaux, je précise), mais comment fait-on pour personnaliser le processus ?

Par exemple :

  • je veux proposer à l'administrateur d'ajouter le nouvel utilisateur dans certains groupes ;
  • je veux envoyer un courriel au nouvel utilisateur afin de lui dire que son compte est créé ;
  • etc.

Et bien ce n'est pas difficile, Debian nous propose une solution simple mais que je ne trouve pas assez propre, c'est pourquoi je me suis fait les deux petits scripts que je vous propose ici.

Lire la suite

Spider's Web de Katie Melua

Cela faisait bien longtemps que je n'avais pas réécouté des morceaux de Katie Melua, et je ne me souvenais pas que c'était aussi bien.

Je craque complètement sur la chanson intitulée Spider's Web (toile d'araignée pour les anglophobes) de l'album Piece by Piece, je vous laisse découvrir…

Les paroles sont présentes dans la suite du billet.

Lire la suite

- page 1 de 2