Sobe Session

Tumblelog de jeu

2010-03-22T21:06:00.000+01:00

Je viens de me lancer dans un nouveau blog (oui, je sais, vu l'activité de ce celui-ci...) à propos de jeu(x), toutes catégories confondus : jeux de plateaux, jeux de rôle, jeux vidéos (de préférence libres ou indés si possible...) et autres.

C'est l'occasion de faire mes petites fiches de jeu, de me remettre un peu à publier sur un sujet qui me plait, et accessoirement de tester Tumblr qui me parait être une plate-forme bien pratique...

Octobre 2009

2009-11-07T11:45:00.001+01:00

Retour sur le mois passé...

Rett.iuwt

Asmanur a eu la formidable idée de créer une plateforme Status.net en parallèle du chan #sdz (et #zds - sur epic.net) et de Buzzerl : ça s'appelle "Rett.iuwt" ou "Twuitter", et c'est ici.

Etant maintenant bien habitué à Twitter, j'avoue que j'apprécie bien ce mode de communication, en particulier comparé à IRC (où, il faut bien le dire, je ne fous jamais les pieds), aux forum et aux réseaux sociaux plus "riches" :

Par rapport aux messageries instantanées donc, c'est beaucoup moins invasif, on gère plus facilement le bruit, et ça a également l'énorme avantage de la persistance (les logs IRC, c'est pénible à lire).
Je trouve les forum souvent trop "statiques". De plus, ils sont généralement axés vers un "thème" en particulier, et se prêtent mal au partage d'items (liens, news, photos, etc...) : ils ne sont pas vraiment faits pour ça.
Les "gros" réseaux sociaux, au sens "grosse appli", sont... lourds. Facebook par exemple, même s'il reste un outil très utile pour garder le contact avec ses potes, n'est pas du tout adapté pour une utilisation en mode "communauté" : trop d'applications (plus useless et mal codées les unes que les autres), trop de bruit et des outils (et interface) trop lourds. Sans parler des problèmes d'accès aux informations privées...

Peut-être Google Wave (NON, je n'ai pas d'invitation, je n'y suis pas !) proposera-t-il quelque chose de nouveau dans ce domaine...

Dans la foulée, je cherchais un client multi-plateforme pour Twitter et Status.net, et je suis tombé sur qTwitter, qui est tout à fait sympathique. Certes, ce n'est pas le plus joli esthétiquement, mais il fait bien le job et a pas mal de fonctionnalités utiles (réglage mises-à-jour, support de Twitter, Identi.ca et autres Status.net, options d'auto-#tag et de raccourcissement d'URL...).

Il reste plus qu'à trouver un moyen propre de faire le pont entre deux comptes/API Twitter et Status.net, et ce sera nickel...

SupInfo

On a beaucoup entendu parler de SupInfo ce mois-ci, dans des termes peu avantageux (euphémisme).

D'abord la sombre histoire d'un étudiant à qui SupInfo refusait de remettre son diplôme qui a fait un peu de buzz. Ensuite, un article assassin d'un enseignant chercheur sur la formation prodiguée par cette école... qui a déclenché pas mal de réactions, notamment celle d'un compte Twitter (@olivier_comes) supposé appartenir à un responsable de cette école (je vous laisse juger au vu des tweets, mais je ne peux que penser qu'il s'agit d'une usurpation d'identité...).

Je ne commente pas l'affaire de l'étudiant, elle me parait louche. Pour ce qui est de l'article, s'il avait été écrit par un membre de la CTI, j'y porterais plus de crédit, même si je pense que l'auteur est de bonne foi.

Je ne connais personnellement aucune personne étudiant ou ayant étudié dans cet (ces) établissement(s). Je ne connais pas non plus particulièrement bien la formation prodiguée.

Pour autant, les problèmes mentionnés (même s'ils sont exagérés, là n'est pas la question) sont pour moi "logiques" pour une formation privée, d'une part, et non sanctionnée par la CTI d'autre part.

J'ai toujours été favorable à l'enseignement (supérieur) public, qu'il se fasse en classes préparatoires, universités, écoles d'ingénieurs ou autre. Ce n'est pas tant une question de gratuité (les écoles de commerce publiques sont payantes par exemple), mais une certaine garantie (imparfaite bien sûr) du mérite de l'intégration : concours après les CPGE, intégration sur titre depuis la fac, etc... L'argent n'est pas supposé intervenir dans cette phase là.

Ensuite, qu'on le veuille ou non, la commission des titres d'ingénieur impose des conditions parfois très strictes aux établissements pour que ceux-ci délivrent le diplôme d'ingénieur. Ce n'est pas pour rien : d'une part, cela assure un semblant de standardisation entre les formations sur les sujets transverses (gestion de projet, management, communication, langues, formation théorique, etc...) quelque soit le niveau supposé de la dite formation. D'autre part, c'est une sorte de "label qualité" applicable à tous ses diplômés. Bien sûr, ensuite, certains étudiants seront plus compétents que d'autres dans un contexte professionnel : c'est pourquoi il est évident qu'avoir un diplôme SupInfo n'est pas un point négatif en soi. Cependant, je comprendrais un recruteur (surprenant, non ?) qui à profil équivalent préfèrerais un candidat avec un diplôme d'ingénieur.

Jeux

Deux très bons jeux ce mois-ci :

Plants VS Zombies : un excellent jeu de stratégie sur PC (Windows, Mac et Web) dans le genre "tower-defense en lignes". Design marrant, bonne durée de vie, musiques géniales... vraiment très sympa.
Professeur Layton et la boîte de Pandore : sur Nintendo DS, dans la lignée du premier épisode. Je craignais un peu que le principe de jeu s'essouffle à cause d'une répétition des énigmes, mais je me trompais : on se régale tout pareil.

Musique et BD

D'abord, l'annonce du nouvel album des Puppetmastaz pour le 9 Novembre (déjà) : "The Breakup". Si vous aimez le Hip Hop un peu décalé, technique et à tendance électro, foncez. Un minimix de preview, absolument génial, est disponible gratuitement ici.

Dans le style vieux Blues et Boogie, je vous conseille Sonny Boy Williamson I, un grand harmoniciste ayant enregistré dans les années 30 et 40. Beaucoup de perles dans sa discographie.

J'ai enfin récupéré la bande originale du film Conan le Barbare, par Basil Poledouris. Hormis le fait que c'est excellent (surtout pour un geek comme moi, ou pour un fan de Naheulbeuk), je pense que c'est à conseiller à toute personne souhaitant découvrir doucement la musique classique : les morceaux sont plutôt courts, les mélodies assez simples et redondantes, mais la composition générale et l'interprétation en font quelque chose de très intéressant.

En BD, le dernier Jiro Taniguchi, "Un zoo en hiver", est très bon : dans la lignée de ses titres "Un ciel radieux", "Quartier lointain" ou "Le journal de mon père", celui-ci apporte une touche auto-biographique supplémentaire (jeunesse dans l'industrie du dessin et du manga dans les années 60), et une ambiance vraiment particulière. Très touchant.

Io Language Libraries and Tools

2009-10-17T17:24:00.003+02:00

Because of its too short name, it's quite hard to find resources for Io language. Besides, I never found some kind of "libraries central" for it (as it exists in other languages like Perl or Ruby for example). Io official website also lacks of links, or some are obsolete...

So, this post is an attempt to simply list existing libs and tools for Io language and provide links to them, with minimalist descriptions.

You are really encouraged to notify me (via the comments for example) missing libs or tools, or to use this raw list for a possible centralization of Io resources (This is what CC licences are for).

IoFE - An alternative command line interface to the IoVM interpreter [old ?]
IoWiki - A simple wiki written in Io (sources)
Backpacking - An Io web framework [old ?]
Ike - Rake (Make in Ruby) in Io [several repos]
Jim - An IRC bot in Io
Muun - A multi-user unified network
Iota - A tiny web app framework in Io [old ?]
Yown - A little web framework for Io (initially developed by _why) [several repos/forks]
Io-snippets - Snippets for Io
Icis - An Io continuous integration server
couchDB-io-viewserver - A couchDB viewserver in Io [old ? - Ok ?]
Io-SCGI - An SCGI implementation for Io
Chordal - An Io library to generate chords [???]
Io-Pack - A pack/unpack implementation for Io
Iospec2 - An RSpec-like tool (behavior driven development) for Io [several repos]
Io-Stuff - Little utilities for Io [Ok ?]
Io-JSON - A simple json pack/unpack for Io
Beanstalk-client-io - A beanstalk client library
IoSVN - Subversion Io language add-on
iorm - A minimalistic ORM [Ok ?]
IoPackage - Io code package manager based on Git repositories
Generys - Web framework in Io [Ok ?]
Netz - A simple webserver abstraction layer for Io [Ok ? New]
couchDB-Io - Io library for CouchDB [New]
IoGraphViz - Binding for GraphViz [New]

Not found:

IoGTK
ModIo
IoL4
It (by Pixar studios)

Sources: Io official website, GitHub

Last update: 17th October 2009

Septembre 2009

2009-09-28T00:22:00.000+02:00

Intro : J'ai décidément du mal à tenir ce blog à jour... Pourtant, il y a bien des sujets dont je souhaiterais parler ici ; mais entre les articles demandant trop d'investissement en temps et ceux qui seraient trop courts, au final, je ne publie pas. Donc j'ai décidé de me lancer dans une série mensuelle, listant rapidement des petites choses intéressantes, tout domaine confondu (enfin, surtout ceux habituellement traités ici...). En espérant donner un petit coup de fouet à ce blog qui refuse de mourir.

Logiciels :

Découvert au taf, Launchy est un petit lanceur d'application bien sympathique, disponible sous Windows et Linux. Très pratique (et libre).

M'étant mis tout récemment à la musique assistée par ordinateur (voir plus bas), je vous conseille Audacity (libre et multi-plateforme) que je découvre pour tout ce qui est enregistrement et montage audio. J'avoue que j'ai toujours eu peur des logiciels de MAO à cause de la complexité de certaines références (genre Cubase), mais là ça se présente de manière plutôt simple, même s'il faut creuser un peu pour certaines fonctionalités.

Enfin, j'ai récemment commencé à utiliser Eclipse au travail... Contre toute attente, je sens que ce soft va me réconcilier avec les IDE : bien que lourd, il fait un nombre de tâches hallucinant et facilite vraiment la vie du développeur sur pas mal de points assez peu intéressants (conventions syntaxiques, intégration du gestionnaire de configuration, génération automatique de méthode, commentaires, détection d'erreurs en live, etc...). J'ai sans doute l'air de découvrir la roue, mais bon... quand ça tourne bien, faut pas bouder son plaisir.

Musique

Certains le savent, d'autres non. Je suis un gros fan de Blues, et je joue depuis "presque" un an de l'harmonica diatonique (blues harp donc). Comme je l'avais déjà dit ici, je pense que ce sujet est un peu loin des thématiques habituelles de ce blog, et donc j'en parle chez Lefty.
Notamment ce mois-ci : un article sur une compilation de Blues très bien foutue pour ceux qui veulent découvrir, et un premier essai d'enregistrement avec Lefty à la gratte (d'où l'utilisation d'Audacity).

Pro

Suite à la fin de ma mission précédente, j'ai enchainé cet été sur un nouveau truc en... Java. Et plus précisément en Java3D.
Ce nouveau job me plait beaucoup, en bonne partie parce que j'apprends énormément de choses nouvelles, et que l'environnement est assez différent de mes expériences précédentes.
D'abord le domaine de la géométrie algorithmique (que je connaissais déjà dans un contexte de calcul scientifique/modélisation mathématique) qui est bigrement intéressant. Pour l'occasion, je me suis d'ailleurs (enfin) payé le Computational Geometry (de Berg - Cheong - van Kreveld - Overmars) que je ne saurais que trop conseiller à ceux qui s'intéressent à ces problématiques (attention cependant, il n'existe pas de traduction).
Ensuite, l'environnement très libre/open source : même si c'est en bonne partie des outils classiques de développement en Java, c'est toujours agréable de bosser avec des choses comme Eclipse (voir plus haut), Ant, TestNG, SVN, TRAC, plein de bibliothèques libres, etc... (plutôt que Visual Toto, des scripts batch halakon, des outils de test et des libs internes foireux, Clearcase et Rhapsody...). Ah oui, et un wiki pour la doc : si c'est pas cool ça...
Bon, et le Java, c'est pas si terrible.

IoGraphViz := Io + GraphViz

Comme je voulais depuis longtemps m'investir dans un vrai projet libre, et qu'en parallèle je voulais me pencher plus sérieusement sur le langage Io, je me suis lancé dans le projet IoGraphViz.
Il s'agit d'un binding, pour le langage Io, de l'outil de génération de graphes GraphViz. Il n'est pas encore stable/mature, mais j'espère sortir assez rapidement une première version fonctionelle. Pour l'instant je me base fortement sur l'équivalent en Ruby : RubyGraphViz, mais je compte diverger de plus en plus de ce (très bon) point de départ.
Ce qui est intéressant en se lançant dans ce genre de projet, c'est que ça implique de nombreuses contraintes qui sont assez formatrices :

Mieux maitriser le(s) langage(s) utilisé(s) bien sûr
Héberger son projet/maitriser un gestionnaire de configuration et/ou de version (dans mon cas, je me suis mis à Git via Github - sous Windows, c'est pas de la tarte au début mais on s'en sort...)
Et surtout rechercher toutes ces petites choses auxquelles on ne pense pas : de la doc sur des points ultra pointus, un générateur de documentation, tests unitaires, etc...

Je compte faire un vrai article d'introduction (in English if you please...) à la lib quand elle sera présentable.

Curiosités du web

International Dialects of English Archive propose des petits fichiers audio à l'écoute illustrant les accents (en anglais) de gens des quatre coins du monde. Amusant et pratique pour bosser son oreille.

Journée Mondiale présente une liste (non exhaustive mais impressionante) des journées mondiales/internationales/européennes/nationales de... tout et n'importe quoi (genre là on est entre la Journée Européenne des Langues et la Journée Mondiale de la Surdité... touss touss).

Buzzerl : un reddit pas bien, fait par des gens biens, utilisé par des gens biens et des gens pas biens (en Erlang).

Fin de projet SCADE

2009-07-10T13:51:00.003+02:00

La fin d'une mission, ou d'un projet, c'est toujours une bonne occasion de faire le point. Je viens de terminer tout récemment une mission de quelques mois en tant que développeur logiciel, en SCADE, pour un système embarqué sur avion. Cette mission a été plutôt enrichissante sur plusieurs points.

SCADE

SCADE est un environnement de développement propriétaire édité par Esterel, et basé sur le langage Lustre. Il cible principalement les applications dites "critiques", dans des domaines divers comme le ferroviaire, le nucléaire, le spatial... et bien sûr l'aéronautique.
Ce que les gens du milieu appellent un peu pompeusement de la "spécification formelle", j'aurais tendance à l'appeler du "codage graphique" (pour un certain nombre de raisons, les ingénieurs systèmes apprécient peu le terme "code"...). En effet il s'agit ici non pas de coder avec des fichiers textes, mais directement avec une représentation graphique (c'est cette représentation, qui se veut le pendant visuel de la spécification textuelle, que d'aucun nomme la "spécification formelle"). Par la suite, cette représentation graphique est convertie en langage Lustre (langage de programmation textuel, "classique"), celui-ci étant à son tour interprété afin de générer le code C (ou Ada, au choix) qui sera finalement executé sur cible.

Alors en pratique, à quoi ça ressemble ? Pour des raisons évidentes de confidentialité, je n'ai pas d'images de mon projet sous la main, mais en gros c'est un espèce d'hybride entre des représentations de fonctions logiques (notation américaine), de machines à état, et de certains schémas UML. Un exemple de chez Esterel ici (machine à état en haut,"workflow" en bas).

N'ayant jamais utilisé ce type d'outil avant, j'avoue que l'adaptation se fait assez rapidement, même si certains aspects restent déroutants (la représentation des machines à états est à mon avis assez peu intuitive par exemple), et si certains côtés sont un peu frustrants (gestion des types...).
Par contre, clairement l'outil possède des avantages sur du codage manuel normal :

Tout l'aspect concurrent et synchrone est épargné au développeur, évitant de nombreuses erreurs
Abstraction également de la gestion de la mémoire (ce qui n'est bien sûr pas le cas en C ou en Ada - de longues heures de debug gagnées...)
Représentation du code sous une forme lisible par quelqu'un ne sachant pas coder (un ingénieur système par exemple)
Annulation du besoin de vérification manuelle sur de nombreux points (revue du code généré notamment)

DO-178B

C'est mon second projet dans ce que les commerciaux aiment appeler "un contexte de DO-178B". En pratique, la DO-178B, est une norme aéronautique pour le développement d'applications critiques (le plus souvent embarquées sur avion). C'est une norme très sévère qui imposent de nombreuses règles pour la conception et le développement logiciel. Notamment :

La gestion de configuration obligatoire
La traçabilité "parfaite" entre les spécification et le code
Les différents aspects de la validation et vérification (revue de code, indépendance entre le codeur et le testeur, couverture des tests...)

Bizarrement, on s'habitue... Quand j'ai découvert cette norme, j'ai plus eu l'impression de la subir que d'en profiter, mais là, ayant participé à la mise en place du process de validation (l'ensemble des règles et documents pour les tests, entre autres), je dois avouer que travailler dans un cadre très strict a ses avantages. De bonnes pratiques sont obligatoires au niveau de la traçabilité par exemple : "Quel bout de code correspond à une spec donnée ?". Ou encore : "Jusqu'à quel point dois-je tester mes fonctions ?", etc...

Au niveau dev...

C'est la première fois que je me retrouvais seul, en milieu pro, à prendre en charge le développement complet d'un soft. C'est un peu flippant au début, surtout quand on a été habitué à avoir des gars très bons techniquement à côté de soi, mais c'est aussi extrêmement enrichissant.
En particulier, le fait de devoir faire soi-même des choix au niveau de l'architecture du logiciel, des conventions techniques, du design, etc... c'est l'une des parties les plus intéressantes du développement (l'implémentation est sympa aussi, hein !).

Sans trop rentrer dans les détails techniques (qui seraient de toute façon une redite de pas mal de principes de base de conception logicielle), voici ce que j'en ai retenu :

Les spécifications, quand elles sont écrites par quelqu'un d'autre qu'un codeur, sont forcément en décalage par rapport aux réels besoins, et par rapport à leur mise en oeuvre. Ce qui veut dire que celui qui code doit participer, et influencer au maximum cette phase de spécification. En gros : participer à cette expression des besoins plutôt que la subir ensuite.
Avant même de réfléchir à la façon d'implémenter les fonctions demandées, identifier les problèmes à venir, d'un point de vue software (pas d'un point de vue système, ou métier), qui se posent et proposer une solution. Par exemple dans mon cas : grand nombre de variables en entrée et en sortie => création de façades ; uniquement des variables booléennes => créations de types structurés utilisés dans les interfaces de chaque fonction ; besoin temporaire de certains modes de fonctionnement => design pattern Strategy (non, il n'y a pas de POO dans SCADE, pour autant ça reste applicable) et séggrégation des fonctions par mode ; etc...
Essayer de piquer les bonnes pratiques des langages modernes et/ou fonctionnels : pas de variables globales, éviter tant que possible les effets de bord, composer ses fonctions, etc...
Le typage, c'est la vie.
Communiquer au maximum : "Mon code est dans tel état là, maintenant.", "Telle partie sera disponible le tant.", "On va avoir des problèmes à tel niveau sur telle spec.", "Je suis en retard par rapport au planning à cause de tel problème.", etc... et de façon systématique et quotidienne. Cela permet d'éviter bien des mauvaises surprises.
Séparer ce qui change de ce qui ne change pas (formulation honteusement pompé à Russ Olsen)
Et les classiques : KISS, DRY, YAGNI, etc...

credits : photo de nacelle par Eric E Johnson

Les promesses de la programmation fonctionnelle

2009-06-23T23:00:00.004+02:00

Disclaimer : Je me permets un post cours et un peu dans l'urgence pour vous proposer un document qui risque de ne pas être éternellement disponible librement... Si le lien ci-dessous ne vous permet pas d'accéder à la version PDF (ici) de cet article, c'est qu'il est trop tard... Désolé.

Juste un petit message pour signaler la publication récente d'un article (scientifique) qui me semble intéressant, à propos de programmation fonctionnelle :

The Promises of Functional Programming,
de Konrad Hinsen (CNRS Orléans)

L'auteur axe sa réflexion autour des qualités de ce type de langages, s'attardant sur la famille "LISP - Clojure" (dans laquelle il inclut implicitement Erlang, pour ceux qui se demanderaient où le placer...) et "ML" ; à savoir robustesse et compacité du code et surtout facilité de parallélisation, un aspect aujourd'hui crucial en calcul scientifique (domaine de l'auteur).

J'espère reparler rapidement ici de programmation fonctionnelle, mais sous un angle un peu particulier, puisque je ne pratique aucun langage fonctionnel à proprement parler...

Bonne lecture !

Algorithme naïf de cryptage d'entrée

2009-04-01T11:21:00.006+02:00

Je vous propose aujourd'hui un petit algorithme dans le domaine de la cryptographie, implémenté en Ruby. Comme vous allez le voir, il s'agit d'un algorithme à clef secrète générée aléatoirement au moment du chiffrement. Cette méthode est assez peu intéressante pour la plupart des applications de cryptage (transfert de message notamment) de par le fait que la clef doit être transmise afin que le destinataire puisse décrypter le message. Dans ce cadre, on utilise plus volontiers la cryptographie asymétrique (RSA, etc...), ou, pour des raisons de performances, une méthode symétrique dont la clef est cryptée de façon asymétrique.

En revanche, cet algorithme me semble utilisable pour un autre genre d'applications : de façon locale, afin de crypter une réception de donnée par exemple.

Contexte

Plusieurs hypothèses tout d'abord. La donnée à recevoir peut être accédée par morceaux (bits, lettres, chiffres, lignes, pages, etc...). On ne connait pas à priori sa taille. On suppose également que l'on peut pareillement accéder à un nombre important de données similaires.

Principe : Se fondre dans la masse

Le coeur de la méthode consiste à noyer l'information que l'on souhaite recevoir (notée A dans la suite, data dans le code) la recevant par morceaux, au milieu d'une foule d'autres informations similaires, de façon aléatoire.
Pour cela, on construit des "cycles" de taille aléatoire, dont seuls certains index (aléatoires eux-aussi) contiennent des parts de données intéressantes. La clé consiste en la liste des cycles utilisées (plus simplement, la liste des couples [occurences de part de A, taille du cycle]).

Le code

Dans mon implémentation en Ruby, j'applique l'algorithme à un tableau. L'input dummies correspond donc à une liste de données. La sortie est la paire [données cryptée, clé]

Cryptage :

A noter que je clone l'entrée data afin que la méthode soit non destructive sur celle-ci.

Décryptage :

On décrypte par morceau correspondant chacun à un cycle de la clef.

Exemple :

Pour tester cette méthode :

Ce qui donne un résultat du genre (pour rappel, la clef est profondément aléatoire...) de celui-ci.

Conclusion

Encore une fois, il s'agit d'une méthode naïve, à utilité limitée (je suis un grand débutant en crypto). Cependant, pour un usage local, elle me semble adaptée, bien que probablement peu performante en terme de vitesse (celle-ci étant conditionnée par l'ampleur des cycles et le nombre d'occurrences par cycle, ici en dur).
J'ai du mal à me figurer de grosses failles dans cet algorithme, si ce n'est pour ce qui est de l'utilisation de la randomisation : 1/ sa complexité étant dans l'absolue aléatoire, elle ne peut être calculée que par majoration dans le meilleur des cas (le meilleur des cas en crypto étant en fait le pire des cas en algorithmique), 2/ des failles existent sur des implémentations standards des méthodes random (présence de cycles, etc... Des méthodes plus abouties existent cependant, notamment celles utilisant des propriétés physiques du matériel informatique, comme la température par exemple).

Notes :
1/ Crédit photo : Jan Chipcase
2/ Ceci n'est pas un poisson d'Avril. J'aime pas cette tradition de clampes.

Comment utiliser Twitter ?

2009-03-27T11:55:00.008+01:00

Vu l'énorme buzz du moment sur le service web Twitter, et les questions que j'entends fréquemment sur celui-ci, il me parait utile d'expliquer le plus simplement possible ce qu'est Twitter, et comment l'utiliser.

Qu'est-ce que Twitter ?

Le terme "Twitter" désigne plusieurs choses : un service web, le site web correspondant et la start-up (entreprise) le gérant/possédant. Je reviendrai sur la différence site / service web un peu plus loin.

Twitter permet de publier des "tweets" (gazouillis en Anglais. Twitter veut donc dire "gazouilleur", d'où les images de piafs du site). Ceux-ci correspondent à des "textes" de 140 caractères maximum, pouvant comporter des liens. Dans une certaine mesure, cela ressemble au "statut" sur FaceBook ("What are you doing ?" - la nouvelle interface de FaceBook s'inspire d'ailleurs de celle de Twitter), ou à l'"état" en messagerie instantané. Un exemple typique en Français (par Genma - vous noterez l'humour, en cette période d'HADOPI...) :

"Une mère insensée" de Christine Albanel (Auteur) en vente, sur Amazon : http://tinyurl.com/cvjvpo De la bonne lecture, en livre de chevet ?

Mais comme on dit, "Dans l'espace, personne ne vous entendra crier". Twitter permet donc de "suivre" d'autres utilisateurs et donc d'être suivis par d'autres utilisateurs. Basiquement, cela signifie que vous verrez leurs tweets (ou mise à jour) et inversement, par ordre chronologique.
Il y a de nombreuses fonctionnalités associées au suivi : blocage d'utilisateurs intempestifs, tweets privés, tweets adressés à une ou plusieurs utilisateurs en particulier, etc... J'y reviendrai plus tard. Twitter permet également dadresser des messages privés directement à un utilisateur (direct message) : pour cela, celui-ci doit déjà vous suivre, ceci afin d'éviter le spam.

Twitter est donc un outil de réseau social plutôt qu'un réseau social au sens strict (comme FaceBook ou LinkedIn). Personnellement, je le vois comme un nouveau mode de communication.
La différence entre site web et service web réside dans le fait que ceux-ci sont découplés. Plus simplement : rien ne vous oblige à utiliser le site web de Twitter pour tweeter, afficher vos tweets et/ou suivre d'autres personnes. Il existe en effet de nombreux moyens d'utiliser ce service : pléthore de logiciels tiers, plugins pour navigateurs, widgets et autres services web. Twitter en propose une liste non exhaustive ici. Dans la colonne de droite de ce blog, vous pouvez par exemple lire mes derniers tweets. Il est également possible de tweeter par SMS via son téléphone.

A quoi sert Twitter ?

Difficile d'être objectif sur ce point, tant les critiques du service peuvent être dythirambiques ou assassines.
Twitter est un outil de communication avant tout. Ce qui est intéressant, c'est qu'il peut être utilisé de nombreuses façons, pour des objectifs divers.
L'une des principales attaques contre Twitter consiste à dire que : "Dire ce que l'on est en train de faire est à la fois narcissique, impudique et contre-productif." (je résume volontairement).
Pour autant, je vous propose dans la suite quelques "modes" d'utilisation de Twitter qui tentent démontrer le contraire, après avoir décrit les quelques "normes d'utilisations".

Comment tweeter ?

Voici quelques normes courantes d'utilisation de Twitter :

RT signifie "ReTweet" : lorsque l'on lit un tweet intéressant et que l'on souhaite lui faire écho, il suffit de le copier et de le tweeter à son tour. Pour cela, on utilise cette syntaxe, avec "source" l'utilisateur du tweet de départ :

RT @source Un tweet très intéressant, sans doute avec un lien.

@user : dans un tweet, mettre @ devant le nom d'un utilisateur, sans espace, permet de mettre automatiquement un lien vers son profil. En particulier, lorsque l'on adresse un tweet à une personne , (pour répondre à son dernier tweet par exemple) le tweet doit commencer par ceci. Exemple :

@toto197 Moi aussi j'ai adoré ce bouquin, même si la fin est un peu abrupte.

#keyword : lorsque l'on souhaite que son tweet soit référencé dans certains moteurs de recherche et/ou puisse être classifié automatiquement dans une catégorie donnée par d'autres services, sites ou logiciels, on utilise le signe # devant le mot-clé employé, sans espace. Par exemple :

Tous à la manif contre #hadopi !

OH pour OverHead : moins fréquent, cela signifie que vous tweeter quelque chose que vous avez entendu. Exemple :

OH Ingenicono va licencier 1 milliard de consultants.

Comment utiliser Twitter : quelques "modes" d'utilisation

Liste non exhaustive, mais illustrant, à mon sens, les possibilités offertes par ce service, avec quelques outils, et exemples de tweets (à titre purement informatif, et non contractuels).

Microblogging : ma vie, mon œuvre, mon cµl

What ?

Grand classique du microblogging que l'on méprise tous (et qu'on est pourtant si nombreux à pratiquer...), il s'agit stricto sensu de tweeter ce que l'on est en train de faire, ou d'une manière plus large, ce qui nous arrive IRL (dans la "vraie" vie quoi...). Bien qu'assez inintéressant, il y a des cas, ou celà permet de rester en contact (d'une certaine façon, à chacun de juger) avec sa famille et ses amis. Aussi, on peut utiliser Twitter comme un IRC/MSN moins invasif.

How ?

Les bons outils pour cela sont (a priori : je pratique assez peu ce "mode") un bon petit pluggin pour son navigateur, histoire d'éviter de passer par le site, voire Flock, et tinypic pour partager ses photos (photos de sa vie, son oeuvre, etc...), et un bon forfait de SMS... A la limite, un logiciel tiers avec notifications (genre TweetDeck) pour une utilisation type instant messaging avec beaucoup de followers/followings. Passer en mode privé (c'est à dire n'autoriser que certainss followers) est une option s'il s'agit uniquement de rester en contact avec des proches IRL.

Like ?

Arrive à l'aéroport.
Bah, le café est pas bon !
Vais faire caca LOL
@sabrinette256 kikoo twa !

Microblogging : partage

What ?

Déjà plus intéressant, on peut utiliser Twitter comme un flux de partage et/ou tumblelog (comme Tumblr par exemple) ; c'est à dire pour partager ses liens web : lectures, images, vidéos, etc... ou ses propres oeuvres.

How ?

Peu de besoins finalement pour ce mode là : tinyurl pour raccourcir ses liens, tinypic pour loader ses images et vidéos et pourquoi un script du type "Tweet This", tweetant automatiquement la page courante de votre navigateur.

Like ?

New blog : http://lesageducontinent.wordpress.com/
Amazing real pixel art : http://www.flickr.com/photo...
Cranial view: http://bp3.blogger.com/_0OX...

Coworker

What ?

Application professionnelle : avoir un état de l'activité de ses collègues de travail. Ne riez pas, dans certains domaines, je pense que celà peut être extrêmement utile, et contrairement à ce qu'on pourrait croire, un gain de productivité. Effectivement, il est parfois vital de savoir sur quelle tâche sont vos collègues. Par ailleurs, je pense qu'on peut facilement imaginer un script parsant automatisant les tweets, et créant une ébauche de relevé d'activité (j'en reparlerai sans doute dans un prochain post).

How ?

Mode privé surtout (le monde n'a pas besoin de savoir, et dans ce contexte, il est contreproductif de suivre quelqu'un d'autre que vos collègues). Eventuellement un notifier discret ?

Like ?

Bug n°256 corrigé
J'attaque la spec IHM-93
En réunion client jusqu'à 16H
@jdupont il y a un soucis dans la 3° partie de ton rapport
Je pars voir l'expert dans 30 min. Pas de question sur le nouveau process ?

Commerce 2.0

What ?

Pas mal d'entreprises commencent à utiliser Twitter pour diffuser des infos, faire des annonces, et même avoir un retour sur leur dernier "produit" ou encore lancer des micro-sondages.

How ?

Les entreprises peuvent assez facilement développer/se payer des scripts ou autres bots tweetant automatiquement leurs infos. WeFollow par exemple, leur permet de se référencer facilement et d'augmenter leur visibilité. Cependant, il est nécessaire que celles-ci comprennent que Twitter n'est pas un média à sens unique, comme peut l'être la télévision par exemple : l'outil perd de son intérêt s'il est uniquement employé pour diffuser, et qu'aucun retour n'est pris en compte.
Par exemple, l'un des développeurs du logiciel Flock utilise régulièrement Twitter pour demander leur avis à ses followers sur les fonctionnalités qu'ils désirent dans le logiciel, comment celles-ci doivent se présenter / s'utiliser, etc... Il a ainsi un retour direct et synthétique (140 caractères...) d'un nombre important d'utilisateurs.

Like ?

Promo au magasin à partir de demain sur les chaussures rouges !
Notre nouveau modèle de netbook 2 Go sortira finalement courant Avril
Participez au concours d'IndusBidule : http://indusbidule.fr/concours/toto
Notre équipe IT cherche un nouveau responsable media : http://recruttruc/offre/244
Hausse de notre action de 7.8% : http://www.tousdanslesbourses.com/blague

Event Media

What ?

Twitter est un très bon outil pour les professionnels de l'évènementiel. Il permet rapidement d'informer de son dernier évènement : concert, festival, exposition, conférence, etc...

How ?

Ici encore pour le professionnel, les scripts et un bon référencement sont les bienvenus. Rien de particulier, si ce n'est que des liens restent nécessaires pour détaillé le tweet.

Like ?

Concert de Lyne la Coquine le 4 à Limoges au Grand Vase : http://llc-music.fr/concerts
Plus que quelques places pour l'opéra de Whessenfyerstrauss à Marseille le 12 Juin : http://...
Finalement, le jeune talent Elvis Presley n'assurera pas ces dates en France à partir du 1er Avril. Pour tout remboursement, contactez http://...

News

What ?

Les grands acteurs du monde de l'information se mettent à Twitter : CNN, BBC, The Guardian Tech, etc... En général, ils proposent des brèves, et des liens vers les articles de leurs sites respectifs. Personnellement, je ne trouve pas encore un intérêt majeur à ce mode là : il réinvente le flux RSS en moins pratique, sans apporter énormément de plus value.

How ?

Pour le follower, un logiciel tiers du type de TweetDeck, permettant de trier les tweets, semble approprié s'il suit plusieurs de ces sources : en effet, le nombre de tweets peut être important, et éventuellement noyer ses autres contacts.

Like ?

Text message system revolutionises medical care in Malawi http://bit.ly/KVw9
Tesla unveils electric 'family car of the future' http://bit.ly/OWmQa
Google cuts 200 global sales and marketing jobs http://bit.ly/D1cHf

Lazy Web

What ?

Ce que j'appelle le "Lazy Web" (litéralement "Web paresseux") est la méthode consistant à demander une information aux autres, sur le web, plutôt que de la rechercher comme un grand garçon (ou une grande fille, ou un grand robot que s'il est sage il pourra jouer à pong). Autant je déteste passablement les gens en abusant sur les forums ("Hé, comment on fé pour désinstaller un logicielle sous L1nux ?" - il faut toujours qu'il y ait une bonne âme (aussi appelée un pigeon) pour répondre à ce genre de topic honteux), autant je dois reconnaître que sur Twitter, c'est un peu différent. D'abord parce que le tweet en question va polluer beaucoup moins longtemps la liste de vos followers que sur un forum ou autre. Ensuite parce que d'une certaine façon, vous vous adressez généralement à moins de personnes. Ensuite, parce que si c'est fait intelligemment, ça peut être efficace.

How ?

Pas d'outils particuliers pour cette utilisation. A noter que contrairement aux modes précédents, il ne saurait ici s'agir d'un mode d'utilisation de Twitter à part entière : qui vous suivra si vous ne faites que poser des questions ? Attention à ne pas en abuser donc...

Like ?

Je me tate entre l'achat d'un eeePC et d'un Aspire One : des avis ?
Quelle galère pour compiler tel logiciel sous Window$ : c'est normal, ou il faut carrément que je le compile sous Nix en croisé ?
Question au peuple : Gmail est mort aussi chez vous ?

Buzz Surfer

What ?

Twitter permet de s'informer des préoccupations des gens l'utilisant, quasiment en temps réel. Pour ceux qui sont accros à la nouveauté, au buzz (comme on dit chez les djeunz) et pour les beta-testeurs et early-adopters de tout poil, c'est une aubaine car certains outils sont vraiment efficaces pour ce faire.

How ?

Principalement ici : l'outil de recherche de Twitter, TwitterSearch. Celui-ci permet d'afficher en temps réel les tweets contenant un mot-clef. Il informe également des sujets du moment. Grâce à l'API très ouverte de Twitter, on voit également apparaître des outils communautaires très intéressantes, comme API's VS Hadopi.
C'est dans ce genre d'utilisation que les mots-clés (avec # devant) et les retweets prennent tous leur sens : référencement, phénomène d'écho, etc...

Like ?

Cuil is really a good... nah, just kidding...

Autres...

Bien d'autres utilisations sont possibles : communauté, jeux (on en reparlera), spam, bots, etc...

A chacun d'utiliser le service comme il l'entend, mais toujours avec moins de 140 caractères.

--------

Les commentaires sont ouverts pour toute question.
Je reparlerai très certainement de Twitter dans de prochains posts.

Animal Quiz en Ruby

2009-03-16T13:26:00.003+01:00

Allez, comme ça fait un moment que je n'ai pas posté de code, je vous propose un petit jeu rigolo : le quiz des animaux, implémenté en Ruby.
Il s'agit d'un petit algorithme tentant de deviner à quel animal vous pensez : pour ce faire, le programme vous pose un certain nombre de questions, puis vous propose un animal. Si celui-ci est l'animal auquel vous pensiez, le programme gagne. Sinon, il vous demande d'ajouter une question (ayant pour réponse oui ou non) permettant de différencier l'animal proposé et le votre, et l'ajoute dans sa base de question.
La structure employée est un arbre binaire dont les branches sont les questions et les feuilles les animaux. Celle-ci est enregistrée dans un fichier YAML dans mon code en fin de partie.

Le code étant un peu long, et en plusieurs fichiers, au lieu de le coller ici, je vous propose d'aller le consulter/télécharger chez pastie (un fichier d'exemple en YAML inclus) :

Le Code

Vous noterez la méthode list_animals de la classe Game, non employée dans mon code, mais permettant d'inspecter le contenu de l'arbre de données (Combien d'animaux ? Plusieurs occurrences d'une même espèce ? Etc...). Le principal défaut de cette approche est que l'ordre des questions influe énormément sur la structure. Par ailleurs, il est parfois difficile de différencier deux animaux avec une question "oui/non" non ambiguë (dans l'appli web du "Génie" ci-dessous, il y a la possibilité de ne pas se prononcer...) : un tigre mange-t-il des souris ?

Pour ce code, je me suis basé sur les règles fixées par le défi Ruby Quiz n°15. L'implémentation qu'ils proposent est d'ailleurs bien plus concise que la mienne... A lire pour plus de détails.

Liens

Crédit photo : L-ines, sous CC. Lien.

I luv' Sneakers : Sneakerz Reddit

2009-03-10T13:58:00.003+01:00

C'est pas vraiment un secret : je suis un gros fan de sneakers (chaussures de sports / urban shoes). Du coup, je viens de lancer un petit subreddit sur ce thème : Sneakerz.

N'hésitez pas à aller jeter un coup d'œil ou à proposer vos liens si vous aussi vous pensez qu'une paire de Superstar est plus classe qu'un costard Hugo Boos.

Loi Création et Internet : Black Out

2009-02-26T09:13:00.002+01:00

Je suis bien conscient que je parle rarement politique ou économie sur ce modeste blog. Je suis aussi conscient qu'il y a probablement, en ces temps de crise, moultes sujets plus importants : des 90000 nouveaux chômeurs en France en Janvier, en passant par les réformes dans l'éducation, la recherche ou les collectivités territoriales, les petits soucis dans les colonies, ou ces pauvres moines tibétains dont on ne respecte pas tellement les droits (de l'homme).

Mais en bon geek occidental égocentrique que je suis, je me dois de faire un petit billet contre cette espèce de bouse malsaine que d'aucuns nomment la Loi Création et Internet (dite loi HADOPI). Je ne refais pas ici le topo sur cette loi en cours d'adoption que bien d'autres auront bien mieux expliquée (cf les liens ci-dessous - pour résumer : liberticide, techniquement stupide et fondamentalement inefficace).

Simplement, en bon mouton engagé, je participe d'une part au black out, qui consiste à peindre son site personnel en noir (vous remarquerez que de par mes compétences et mon amour assez relatifs pour le CSS, seule ma bande latérale se retrouve partiellement noircie). D'autre part, je viens de signer à l'instant la pétition lancé par le magazine informatique SVM (qui rappelons-le, ne sont pas d'affreux gauchistes aux relents bolchéviques, le couteau entre les dents, etc... NI -et ça aussi c'est important- des geek boutonneux de libristes utopistes qui font pleins de trucs illégaux et gratuits avec leurs ordinateurs, tellement qu'ils s'en servent bien.).

Bref, dans quelques mois, quand vous serez sous les verrous parce que votre voisine de 12 ans a craqué la clé WEP (15 à 30 min actuellement) de votre DuconBox pour télécharger illégalement le dernier single de Laurie, vous pourrez vous aussi, vous la jouer prisonnier politique si vous prenez vos disposition maintenant. A bon entendeur, je vous laisse de la lecture :

Ya un Ternet qu'est tout noir, par Petaramesh.
Hadopi : le scénario catastrophe mais plausible de l'Isoc France, chez Framasoft (prospective à lire absolument).
La loi Création et Internet, le chant du cygne et le maquis, chez Framasoft.
Projet de loi Création et Internet : l'April s'insurge et appelle à la mobilisation, chez Framasoft encore.
Pétition contre ce projet de loi chez SVM.

Une dernière chose : comme le prédit la prospective assez inquiétante, cette loi et les moyens qu'elle envisage ne seront pas efficace contre les geeks, les hackers et les libristes, bien qu'elle les fasse passer d'office pour des petits bandits. Que tout soit bien clair entre nous, l'Etat, en France, actuellement, n'a absolument pas les compétences en informatique (mais pas que) nécessaires pour faire appliquer cette loi (pour preuve, la récente infection par Conficker de réseaux de l'armée). Et on ne fait pas voter une loi sans volonté de la faire appliquer.

Diffusion du libre

2009-02-24T09:32:00.000+01:00

Je ne sais pas si c'est une fausse impression de ma part, mais j'ai l'impression que la notion de logiciel libre est plus connue et mieux comprise par le grand public qu'il y a quelques années. Bien sûr, il reste du chemin à parcourir et de la "propagande" à faire, mais il me semble qu'il y a évolution (même si "libre" reste trop souvent synonyme de "gratuit").
Essayons de synthétiser les vecteurs de cette évolution, ou du moins, les facteurs contribuant le plus significativement à la propagation de la "culture libre" (au sens plus large qu'uniquement logicielle).

Vecteurs de diffusion de la "culture libre"

Bon, je passe sur Internet. C'est évidemment la clef de la naissance, l'évolution et la réussite du libre, depuis le départ. D'ailleurs, Internet et le web sont construits principalement sur des technologies (et des principes) libres ou du moins ouvertes : HTTP(S), SSH, CGI, FTP, Javascript, PHP, etc... (certes, il y a aussi le Flash...).

La fondation Mozilla, via Firefox a été et reste un acteur très important de propagation du libre. Même si la fondation est assez souvent critiquée par la communauté du libre, pour des raisons aussi diverses que de validité variable, elle mérite que l'on reconnaisse le bénéfice de ses actions.
D'abord Firefox est un bon à très bon produit, surtout comparativement à Internet Explorer. Pour autant, je ne pense pas que ce soit le logiciel libre le plus répandu auprès du grand public (les chiffres me manquent pour vérifier ça : si quelqu'un connaît une bonne source de statistiques à propos du libre, je suis preneur) : d'une part, Internet Explorer est encore majoritaire en terme de visites web, et d'autre part, on a tendance à oublier pas mal de programmes, énormément employés (en bonne partie de par leur gratuité) : VLC, eMule, Vuze (anciennement Azureus), The Gimp ou Java... La différence avec ces logiciels, est que Mozilla met largement en avant le côté libre de Firefox (et de ses autres produits), ce qui n'est pas le cas sur ces autres. C'est assez similaire sur la suite OpenOffice de Sun : le côté libre/open source est souvent souligné dans les pubs.

Wikipédia a, je pense, indirectement, mais fortement, contribué à diffuser la culture libre. Le principe d'encyclopédie collaborative est bien connue du public. Le droit de réutilisation du contenu est également bien admis (bien que les conditions de rediffusion imposées par la license de documentation libre GNU (GFDL) le soient nettement moins...). Sur les principes, le logiciel libre et les règles de Wikipédia sont très proches : tout le monde peut participer/contribuer, réutiliser, diffuser, etc... C'est en bonne partie Wikipédia qui fait connaître les licences Creatives Commons via Wikimedia Commons (de plus en plus de sites les mettent en avant cependant, comme Flickr récemment). Ces principes étant compris pour l'encyclopédie, ils deviennent plus clairs lorsqu'ils sont expliqués pour les logiciels.
Par ailleurs, la communauté libre utilisant Wikipédia de façon soutenue, les projets libres sont souvent mis en avant dans les articles du site (parfois de manière subjective et un peu pénible d'ailleurs : je ne pense pas qu'on ait besoin de ça...), ce qui permet une certaine forme de publicité : la pub par la doc (un logiciel (ou autre d'ailleurs) existe-t-il vraiment s'il n'a pas d'article sur Wikipédia ?).

Ensuite, phénomène commercial plus récent, l'apparition des netbooks ou ultra-portables a contribué à faire connaître le logiciel libre et surtout Linux (pas forcément en bien cependant) à un public de néophytes (à commencer par les vendeurs informatiques eux-mêmes...). Je ne suis pas persuadé que les gens aient bien compris la notion de logiciel libre en achetant un eeePC sous Xandros, mais ils ont au moins compris la différence de prix avec Windows... c'est déjà ça (c'est l'argument principal de vente de Linux, hormis la moindre consommation mémoire par rapport à Vista ou même XP).
Par contre, j'ai des doutes plus que prononcés sur l'efficacité de la "pub" des netbooks pour Linux. En effet, les 2 distributions majeures sur ces machines (majeures car les plus "vendues") sont Xandros (eeePC) et Linpus Linux (Acer Aspire One) : ces 2 distros sont... nazes. Bloquées, interfaces trop simplifiées, modification constructeur de packages "basiques" (sous Linpus : Firefox, Pidgin notamment...)... Bref, je les trouve extrêment mauvaises, assez loin de l'esprit de départ de Linux, et forcément décevantes pour le grand public issu de Windows XP. Il y a cependant des exception comme la Suse SLED sur le MSI Wind par exemple, ou d'autres sous Xubuntu.
Il faut par contre noter que l'apparition de ces machines a pas mal boosté la communauté et les entreprises sur le développement, la relance, ou l'adaptation de distros adaptées : gOS, Xubuntu (mon choix sur Aspire One A150 : XFCE devrait vraiment être relancé par les netbooks), Ubuntu Netbook Remix, Joli Cloud (à venir ?), Android (pas mal de boulot a été fait pour récupérer le dev effectué pour les OS de mobiles ou PDA)... plus l'adaptation matos pour les "grandes" distributions existantes : OpenSuse, Ubuntu, Mandriva, etc...
Je suis mal renseigné sur les BSD, mais il serait intéressant de savoir comment ces communautés ont réagi par rapport à ces nouvelles machines.

Bien sûr, il serait injuste de ne pas parler ici du travail constant fait par la communauté dans son ensemble : développement bien sûr, mais aussi et surtout : rencontres, stands, aide, forums, install parties, propagande, pétitions, etc... C'est un boulot souvent ingrat, faut reconnaître le mérite des gars et des gyals qui font ça (bénévolement en général, rappelons-le).
C'est aussi eux qui diffusent l'information lorsque le logiciel libre est adopté par une grande entreprise ou mieux, par une administration de l'état : c'est souvent un bon coup de pub pour le libre.
Plus méchant, les procès contre les entreprises ne respectant pas les licences libres (en France on a eu Free notamment pour du soft intégré dans la Freebox si je me souviens bien) ou contre les monopoles (Microsoft, bien souvent... mais bientôt Google probablement) font parler du libre, et sont toujours une occasion d'expliquer les fondamentaux.

Cela dit, tous ces facteurs doivent, selon moi, à terme devenir de moins en moins significatifs. Même la partie "éthique" du LL passe, à mon avis, au second plan derrière la qualité logicielle. Je ne parle pas ici d'une quelconque norme industrielle bancale : je parle simplement du fait que de par leur nature, les projets libres, ou open sources (sous réserve d'être suffisament "importants") doivent logiquement être d'une qualité supérieure à leurs homologues propriétaires (et à fortiori freewares). Cela peut se constater déjà sur de nombreux exemples : Firefox est probablement le meilleurs navigateur web actuellement (même si Opéra ou Chrome se défendent), la JVM est toujours probablement la meilleure machine virtuelle sur le marché (depar sa portabilité : faut se méfier de .Net sur d'autres aspects...), les langages libres sont systématiquement meilleurs que leurs homologues propriétaires (troll ?), OpenOffice arrive petit à petit au niveau d'offre de Microsoft Office, en science de nombreuses libs sous GPL ou autre dominent l'écosystème (Lapack entre autres...), Linux (troll ?), etc... Je n'ai pas parlé ici des domaines que je connais mal comme le P2P ou la messagerie instantanée où il y aurait des choses à dire...
C'est à mon avis sur ce point qu'il faut appuyer encore et toujours pour convaincre. Il faut croire que Microsoft a droit à l'erreur avec Vista, les migrations d'OS ayant surtout profité à Mac OS et à... Windows XP (!), mais dans le libre, un nouvel utilisateur déçu, c'est un utilisateur perdu ad vitam aeternam. Au boulot ! ^^

Notes :
Je comptais initialement faire un article pour présenter quelques logiciels libres que je considère comme étant injustement méconnus du grand public (Thunderbird, Pidgin, Sage et Freemind probablement). M'étant un peu enflammer sur la diffusion du LL, j'ai pas envie de coller le reste à la fin, ça viendra dans un prochain article.

Je ne prétends aucunement faire autorité sur les questions évoquées ci-dessus (même si mon "style", je m'en rends compte et m'en excuse, peut le laisser penser) : c'est plus un avis personnel, pour invitation à la réflexion et à la discussion sur ces sujets (les commentaires sont grand-ouverts).

Crédit images, par ordre d'apparition : libre.taxi par Gabriel Juan (utilisation commerciale interdite),

Programmation poétique - Chapitre VII : Ton langage pue du cµl n°2

2009-02-19T09:17:00.001+01:00

Disclaimer : Attention, article violent : âmes sensibles, femmes enceintes et handicapés du second degré s'abstenir. Malgré ses côtés provocateur, insultant et inutilement vulgaire, cet article se veut humoristique et satirique : l'auteur du présent article ne saurait donc être tenu pour responsable des symptômes suivants suite à sa lecture, même partielle (liste non-exhaustive, donnée à titre d'exemple) : nausées, vomissements, chocs anaphylactiques, chutes de phalange(s), déclenchements de diabète, crises d'épilepsie, ruptures de certitudes programmatiques, constipations, inflammations du nerf trollien, asthmes, infections du compilateur et céphalalgies.

~=o=~

Je me suis fait rouler sur le pied par une voiturette sans permis, ma nouvelle voisine a l'orgasme facile, bruyant et à répétition (à 2H30 du matin en semaine), mon responsable au boulot estime que prendre des vacances au bout de seulement 12 mois de travail, "ça fait pas sérieux", mon PC s'éteint tout seul sans prévenir lorsque j'appuie sur 4 chiffres d'affilé, Facebook vient de décider qu'il posséderait mes données perso et celles de mes 3 seuls amis même après ma mort et la leur (ah tiens, non finalement ?) et un pigeon s'est laissé allé sur ma modeste Merco (neuve) en sortie de station de lavage.
Bref je suis pas jouasse.
Du coup, je vais cracher sur quelque chose pour me détendre : les langages de programmation par exemple. D'une part parce que j'ai mis "n° 1" sur l'article précédent, donc faut bien continuer la série (sinon c'est pas une série, c'est un article tout seul : on se comprend ?) et d'autre part, pour rappeler au monde que moi aussi je sais troller comme un bon gros geek moyen (surtout qu'on cherche à m'asticoter en ce moment...).
Donc, ton langage pue du cµl...

C

Le C pue du cµl.
Ah le C ! Ce beau langage venu des temps lointains... Ses pointeurs, ses références, ses allocations mémoires... Si les performances ont un prix, en C, c'est celui d'un sol intégralement recouvert de peaux de bananes trempées dans l'huile d'olive sous un coulis de vaseline tiède (ça glisse quoi...).
Ah, les instructions préprocesseur, et leur infinie élégance... Ah, le typage faible ! Ah, le paradigme procédural pur de chez pur ! (Oui, je suis au courant, c'est possible d'implémenter la POO en C. Un petit exemple dans un code en production s'il vous plait ? Merci.)
Le plus marrant avec le C, c'est que ses bonnes performances deviennent franchement une malédiction quand on voit tous les jeunes tanchards muants qui s'y frottent. "Attends, han, ton serveur le fait pas en Python/Ruby/Perl, t'es fou, c'est vachement plus speed en C !". Ben voyons mon cochon : ton code sera seulement 3 à 5 fois plus long, et tu gagneras bien 5 milisecondes par requêtes (sur 1 seconde, c'est vrai que ça vaut bien le coup pour un projet amateur...), et tu mettras juste 10 fois plus de temps à le coder. Mais soit, il faut bien que jeunesse se fasse (casser les dents à coup de null pointer exception).
Bon, je reconnais qu'il est difficile d'attaquer le C en tant que langage sur le côté technique. C'est un langage globalement bon, la preuve est qu'il est majoritairement utilisé dans... Attendez voir ! C'est marrant ça : dans le monde du logiciel libre, le C doit (devait ?) couvrir environ 95% du pool de code sous licence approuvée par la FSF. Genre tout GNU (sauf Emacs en LISP, hahaha. Hum...), la majorité du noyau Linux, les gestionnaires de fenêtres, les BSD, and so on... "Pire", la majorité des compilateurs et interpréteurs des langages modernes sont implémentés (ou du moins pour la version standard) en C : gcc, gfortran, gnat (Ada95), g++, Io, MRI (Ruby), CPython, Bigloo (Scheme) and so on... En quoi c'est un problème ? Attendez les gars, on ne peut pas décemment cracher pendant 20 ans sur Microsoft pour sa position dominante, son monopole et blablabla et laisser une technologie, aussi bonne soit-elle rester trop majoritaire ("position dominante", souvenez-vous !) dans son propre écosystème logiciel, si ? Ben si apparemment. Cela dit, vu le temps qu'il a fallu au monde libre pour se mettre à critiquer Google et Apple, on est plus à ça prêt (c'est vrai que c'est bien plus rigolo de se br4nler la nouille des heures sur les différences entre la GPL V2 et V3...). C'est quand même pas si compliqué de recoder KDE en Erlang, m3rde !
Le C sent le cµl dépassant son allocation mémoire (error at runtime).

Python

Le Python pue du cµl.
Même si c'est pas vraiment de sa faute... Bon alors d'accord, on peut critiquer l'indentation obligatoire. Et c'est vrai que c'est trop laid (même si l'indentation "çay b1en"). On pourrait aussi contester le principe du "One and only one way to do it". Et de fait, je peux vraiment pas blairer cette approche. On pourrait, trouver les notations syntaxiques vraiment moches : elles le sont. Enfin, on peut légitimement trouver que la POO est quand même pas glorieuse.
Mais tout cela n'est que broutille face au réel problème de Python. Je parle bien sûr de sa communauté. En effet, la communauté Python possède probablement en son sein le plus grand nombre d'intégristes barbus pré-pubères (la barbe est donc un pastiche) que le monde ait jamais connu.
L'occupation principale du pythoniste convaincu (notez que je ne généralise pas : il y a également des pythonistes pas convaincus, ainsi que des pythonistes asthéniques), plutôt que produire du code Python, est de déféquer dans la bouche des gens pratiquant d'autres langages. Leurs cibles principales sont bien sur les codeurs Perl et Ruby, mais ils s'attaquent également avec la plus grande vaillance à d'autres langages plus costauds (mais néanmoins olfactifs) tels que le C++. Certes ce comportement se retrouve dans bien des communautés de devs... Mais ça se ressent sans doute plus chez les pythoneux. Moi, de mauvaise foi ? Cette page de Wikipédia devrait vous convaincre...
Ces "zealots" ne s'arrêtent cependant pas à de simples attaques directes contre d'autres langages. Inspirés par la propagande faite pour leur dialecte bien aimé par leur grand frère Google ("Nan, mais Python C tro bien : c'est utilisé par Google et la NASA !!!". Voui voui voui...), ces talibans du code source pousse le vice jusqu'à désigner Python comme LE langage implémentant un logiciel donné. Et là ça devient drôle : quelques exemples. Sur Wikipédia tout d'abord, on retrouve fréquemment des programmes "implémentés grâce au langage Python" (merci vieux !). Jusque là pas de problème. Cela dit, je doute qu'Abaqus (voir historique), code de calcul en mécanique solide, soit codé intégralement en Python. La première fois que j'ai lu ça, j'avoue que j'ai bien rigolé... Dire qu'il y a des gars qui ne doutent pas une seconde qu'un code de simulation numérique "lourd" (c'est régulièrement utilisé professionnellement pour passer des calculs, sur clusters, d'une durée de 3 à 10 jours...), vieux de plusieurs décennies, puisse être entièrement en langage de script... (même s'il est vrai que leur utilisation est et sera, je l'espère, de plus en plus importante dans le domaine). Autre exemple, cet article chez Wired (magazine de geeks pourtant réputé - article un peu daté) désigne le logiciel libre de mathématiques Sage comme étant codé en Python. Ben tiens... C'est rigolo, parce que l'intérêt principal du libre (hormis que c'est quasiment toujours gratos...), c'est d'avoir accès au code source. Du coup, je suis allé voir. Hé bien les enfants, c'est pas faute de ne pas l'avoir écrit :

Sage has significant components written in the following languages: C/C++, Python, Lisp, and Fortran. - README.txt

On peut également légitimement penser qu'il utilise pour la partie build/admin le Perl et le M4, vu que les interpréteurs associés sont nécessaires à la compilation du programme... Du coup c'est pas entièrement en Python ? Etonnant... c'est pas ce qu'il y a écrit sur Wikipédia là encore...
Dernière chose, ces fameux zealots ont souvent une excuse pour être aussi souvent ridicules : ce sont des (gros) n00bs. Python est très populaire (ça c'est pas un reproche), du coup il est souvent conseillé aux jeunes débutants en programmation par leurs aînés. Ces petits bons-à-rien prenant exemples sur leurs aînés sus-nommés (symbole du père, Freud, tout ça...), ils crachent eux aussi sur les autres langages et sont d'une mauvaise foi égale justement à la foi qu'ils ont en leur sacro-saint serpent (cf. la secte dans Conan le barbare).
Le Python sent le cµl de jeune intégriste reptilien qui indente.

Visual Basic

Le Visual Basic pue du cµl.
Rassurez vous, je vais faire court. Tout d'abord, précisons que tous les Basic puent du cµl : Visual, Pure, Small, Dark, for Application... Tous. Mais c'est sur le Visual, puisque le plus répandu, que je vais m'étendre (au sens figuré).
"Visual" tout d'abord. "Visual" ça craint parce que c'est Microsoft. J'insiste pas : j'aime pas tirer sur les ambulances, même quand elles sont en or massif avec des jantes en caviar. Mais "Visual" ça craint aussi parce que ça évoque GUI. Et la GUI est à la programmation ce qu'une bonne claque dans la gµeule est à la vie en général : c'est parfois nécessaire, mais c'est jamais agréable.
Ensuite il y a "Basic". Je rappelle qu'au départ, le Basic est basé sur le Fortran (cf article précédant de la série). Alors s'il est vrai que c'est dans les vieux chaudrons qu'on fait la meilleure confiture d'oignons, faut quand même faire gaffe à quel chaudron on prend... Non, ce langage est simplement médiocre.
Le vrai côté puant du Visual Basic, c'est, je pense, qu'il s'agit d'un langage propriétaire. En soi, c'est abbérant que des développeurs (et surtout, les entreprises qui les emploient) osent baser leur propre produit sur une technologie sur laquelle ils n'ont aucun droit, ni aucun contrôle (que ce soit au niveau de ses spécifications ou de son évolution). C'est probablement ce qui explique les problèmes (doux euphémisme) liés aux changements de version (VB6, VB.Net, etc...) et le passage des applications au C#. Sur ce point, je crois que c'est même plus un problème d'odeur : c'est le stade de l'arme chimique (mortelle ?).
Je ne pense pas qu'on puisse parler de communauté pour le VB (pas au même sens que pour les langages libres en tout cas). Pour les autres Basics, elles sont majoritairement composées de jeunes pinpins boutonneux voulant (TOUS !) coder un MMORPG ("mieux que WoW") seuls, et après 2 (longues) semaines d'apprentissage. Je suis de tout coeur avec vous les gars.
Visual Basic sent le cµl de Big Billou (qu'est pas t'a toi !).

~=o=~

Que les petits oubliés de la procédure se rassurent, ceci n'est qu'une seconde partie : je m'amuse bien en trollant gratuitement, je compte bien continuer. Sur ce, j'ai un voisin à castrer (et p't'ê't bien un manager...) avant de débuter à la chasse au pigeon (et p't'ê't bien au manager...).

Programmation poétique - Chapitre VI : Ton langage pue du cµl n°1

2009-02-16T05:51:00.001+01:00

~=o=~

Un mois que je dors plus, ma copine m'a lâché pour un orang outang ingénieur commercial, j'en suis au 6ème Blue Screen of Death de la journée, mon manager a été obligé de baisser mon salaire à cause de la crise (le pauvre, il va pas pouvoir s'augmenter cette année), ma gangrène au pied me fait un peu de soucis ses derniers jours, et en plus, à midi, c'était navets ou blettes.
Bref je suis pas jouasse.
Du coup, je vais cracher sur quelque chose pour me détendre : les langages de programmation par exemple. D'une part j'en ai croisé quelques uns ces derniers temps, et d'autre part, ils sont vachement moins forts à la bagarre que la plupart des gars sur lesquels je pourrais avoir envie de déverser ma bile (et accessoirement, il a été prouvé qu'ils n'appréciaient pas le contact de la salive ou de la bile d'autrui. C'est pas le cas de toutes les personnes sus-non-nommées...).
Donc, ton langage pue du cµl...

Fortran

Le Fortran pue du cµl.
Pour rappel, le Fortran n'est pratiqué que par de vieux clampins de scientifiques qui codent comme des pieds de cul-de-jattes malgré leur expérience paléontologique : goto partout, noms de variables et de fonctions d'un demi caractère, effets de bords, commentaires inexistants ou ridicules... que du bonheur. Le Fortran n'est pas sensible à la casse : c'est pas chouette ça ?
Il faut par contre porter au crédit des gens bossant sur ses compilateurs un exploit considérable : il n'existe absolument aucune norme pour la compilation de ce langage. Ce qui veut dire que l'on a aucune garantie que les résultats (résultats numériques j'entends : que du calcul en Fortran, on va pas non plus faire du web avec cette bouse !) donnés par un exécutable pondu par un compilo donné soit obtenus à nouveau avec un exe pondu par un autre compilo. Je rappelle aux enfants ici présents que le Fortran a grosso-modo 40 ans, ce qui laisse un rien de temps pour mettre en place ce genre de chose...
Je fais l'impasse sur les normes de codages moches, les variables globales COMMONS, la gestion des chaînes de caractères, la tentative lamentable d'insertion de la POO dans les versions récentes, les formats, les variables implicites, etc...
Le Fortran sent le vieux cµl.

OCaml

L'OCaml pue du cµl.
C'est un langage d'universitaires élitistes qui se la pètent avec leurs "tuples", "motifs", "inférence"... bref que des termes que personne ne b1te. Déjà que c'est assez fastidieux à lire, ça n'utilise que des concepts "rares" pour faire joli et gagner trois lignes de code, ou un effet de bord, voire un +1 en "beauté mathématique".
OCaml est sensé être super-méga-performant-pas-loin-du-C-et-du-Fortran, mais bizarement, personne ne l'utilise en calcul scientifique lourd... c'est d'autant plus c0n que c'est à peu prêt le seul endroit où ça sert, les perfs. OCaml ne supporte pas la surcharge des opérateurs, du coup pour aditionner 2 flottants, il faut utiliser l'opérateur "+." : c'est pas vilain ça ? La communauté OCaml est... non, en fait y en a pas.
Le truc probablement le plus ridicule : systématiquement, lorsqu'un débutant pose une question sur la POO en OCaml, il se voit répondre que c'est pas important, ou que c'est un peu spécial, ou que c'est pas utile dans son cas... A quoi ça sert de mettre "Objective" dans le nom, bande de blaireaux ?
L'OCaml sent le cµl usé sur les bancs de la fac.

Groovy

Le Groovy pue du cµl.
Déjà, son nom est naze. Ensuite, il ne tourne que sur la JVM, et ça, "çay mâl" (cf Java). C'est lent, hybride et pas beau. On verse chaque fois sa petite larme lorsque :

"toto".class

nous renvoie :

class java.lang.String

Pourquoi pas "java.jre_v1056.j2ee.lang.stdlib.groovy.String.gString" ? C'est vrai, quoi, ce serait beaucoup mieux précis plus bien !
Malgré tous les efforts de Sun, Groovy n'est pas populaire (c'est pas parce que ya trois c0uillons sous Grails...). Et de fait, ce langage ne sert à rien : JRuby, Jython, Javascript et compagnie sont déjà là (et mieux).
Groovy sent le cµl moitié Java, moitié Ruby et re-mi-ours derrière.

Io

Le Io pue du cµl.
Il faut franchement avoir le sens marketing d'une mouette albanaise (qui ne vend pas beaucoup de brosses à dents) et la maîtrise des outils de recherche web d'un crabe des îles Kouriles (qui, rappelons-le, n'ont pas encore l'ADSL) pour avoir l'idée sublime de nommer son langage "Io" (prononcé "Ayo" comme les rappeurs quand ils font "Ayo ayo, Wass'up N1gga !"). Deux lettres. Pratique pour Google ! Surtout quand ces deux lettres signifient "Input/Output", terme un tant soit peu employé en programmation... Crét1n...
La documentation fait l'impasse sur énormément de méthodes de base : pratique pour débuter !
A ce jour, il est possible d'estimer la taille de la communauté des utilisateurs de Io grâce à son reddit. Celui-ci compte 24 abonnés (3172 pour Ruby à titre comparatif). Il est cependant fortement probable que certains soient des redditeurs débutants s'étant trompés en s'y inscrivant. Une petite vingtaine donc.
Ah oui : il n'y a quasiment aucune lib, et les seules existantes ne marchent pas vraiment bien... mais bon, comme tout le monde s'en br4nle...
Io sent le cµl de vache grèque abandonnée.

Java

Java pue du cµl.
Java, c'est avant tout une machine virtuelle permettant la portabilité des applications, blablabla... Cela dit, vu que le C tourne toujours à plus d'endroit que la JVM, et bien... avant de sentir mauvais, le Java ne sert surtout à rien, à part à faire dresser le k1k1 des chefs développeurs (ceux qui codent plus quoi) en entreprise.
Chefs développeurs criant à tue-tête sur leurs ingénieurs software (autres appellations possibles) pour qu'ils tiennent leurs délais parce que "depuis qu'on utilise le framework "Swing 40K" au lieu du "JRE v6", on est sensé avoir un gain de productivité de 50% (au bas mot, c'était écrit chez Sun !) et que, ben, donc du coup, on a plannifié les dates de livraison avec ces chiffres et que là on est en retard bande de faignants !". Ben tiens, t'as qu'à coder toi, conn4rd.
Ingénieur software, sinistre p1sseur de code sur- ou sous-payé (non, pas entre les deux), qui passe plus de temps à se (dé)battre avec les spécs du clients et les design patterns imposés (et inutiles 90% du temps) qu'à apprendre à coder correctement ou même, à simplement coder ("de toute façon, il s'en fout, il est dans les télécoms de formation, alors hein !"). Du coup, avec le domaine web et le Fortran (cf ci-dessus), c'est probablement le Java qui a le "code moyen produit" le plus moche.
Enfin, le Java produit un grand nombre d'onomatopés à l'haleine lasse (qui pue donc) : "Sélannnn !", "Sarââââmmm !" ou "Saramsamèrlapuuuuuuute !". On pourra me montrer tous les benchmarks de la créations sensés prouver que Java n'est pas si loin du C++, je reste convaincu que c'est lent. En fait, j'ai même un indice : la petite icône de la JVM est toujours présente en bas d'écran quand les cris ci-dessus sortent de mon acerbe bouche. Si ça c'est pas un signe...
Techniquement, le code n'est pas beau et est verbeux, l'introspection est hyper-lourde, bref...
Le Java sent le cµl professionnel certifié par Sun (mais en retard sur son jalon).

~=o=~

Que les petits oubliés de la procédure se rassurent, ceci n'est qu'une première partie (à ceux qui se posent la question, oui, je ch1erais aussi sur le Ruby : qui aime bien châtie bien). Trop courte, je vous l'accorde, mais là je dois m'amputer le pied pour l'envoyer à un primate de mes amis, avant de "régler" un bug de Windows avec le crâne de mon supérieur hiérarchique, et d'aller me faire un petit roupillon (si j'arrive à digérer ces maudits navets).

Langages en construction

2009-02-15T12:10:00.001+01:00

Il existe littéralement plusieurs centaines de langages de programmation. Et malgré ce, de nouveaux langages continue d'apparaître chaque année, développés par de grosses boîtes ou par quelques passionnés. Je n'ai pas vraiment envie de trop discuter de l'intérêt de développer de nouveaux langages aujourd'hui, simplement :

Oui, il existe déjà de nombreux langages de très bonne qualité, spécialisés ou non, largement employés ou non, dans la plupart des paradigmes connus.
Oui, la qualité de langages récents comme Io, ou le succès d'autres comme Lua justifie de continuer à en développer d'autres.
Non, un langage n'est pas "indémodable" ou éternel : le Fortran et le Cobol, notamment, doivent être progressivement abandonnés et remplacés.

Par ailleurs, quand on aime la programmation, le processus de création d'un langage, ses étapes de développements, les choix faits sur ses caractéristiques, son (ou ses) paradigme(s), son implémentation, etc... sont particulièrement intéressants.

Je vous propose donc de jeter un coup d'oeil à 4 langages actuellement en construction :

Cat

Cat est un langage interprété de haut niveau, "stack-oriented", comme le Forth, et fonctionnel. Des 4 que je vous propose dans cet article, c'est probablement le plus avancé au niveau de son développement, celui-ci ayant débuté en 2006, malgré la présence de bugs conséquents (flottants et récursivité notamment).

Les langages de ce type, à pile, sont relativement peu nombreux : Forth, Joy, Factor, PostScript et quelques assembleurs en gros... Cat ne rentre donc pas dans une niche trop saturée. Ce paradigme est assez intéressant et original... et déroutant : il utilise la notation post-fixée (on en parlait ici) qui reste plutôt rare, et la manipulation de la pile demande un certain temps d'adaptation. Cela dit, pris comme un jeu, c'est assez amusant.
Le côté fonctionnel du langage est dû au fait que toute instruction correspond à une fonction appliquée à la pile. Le langage supporte aussi une forme de macro.
Petit plus, le typage est statique et inféré (comme en OCaml par exemple).

La version actuelle de Cat est implémenté en C#. Oui, je sais, berk. Cela dit, d'une il compile sous Mono et donc est utilisable partout (théoriquement...), et d'autre part, une machine virtuelle en C++ est actuellement en cours de développement par Christopher Diggins.

Vous pouvez aller jouer avec, directement en ligne sans rien installer, grâce à cet interpréteur online (Allez y je vous dis, c'est rigolo ! Par contre, tout le langage n'est pas dispo dessus...).

Exemple de la factorielle naïve (récursive) :

Ioke

De ces 4, Ioke est peut-être le plus "sérieux" et le plus suceptible de connaître le succès auprès des programmeurs amateurs et même professionnels. Ioke (prononcé "Ayoki", comme "Io" en anglais et "Loki", le dieu scandinave) est développé par Ola Bini qui travaille également sur JRuby (implémentation de Ruby sur la JVM), entre autres.
Ioke est un langage dynamique, orienté objet, à prototypes, tournant sur la JVM, et inspiré par Io, Smalltalk, LISP et Ruby. Sa première version est sortie il y a seulement quelques mois.

Bien que je ne l'ai pas testé, je trouve Ioke très prometteur pour plusieurs raisons. D'abord parce qu'il s'inspire de très bons langages et que son paradigme (OO à prototype) est très intéressant. Ensuite, qu'on le veuille ou non, parce que le fait qu'il tourne sur la machine virtuelle Java lui ouvre les portes du monde professionnel : ce n'est pas une garantie d'utilisation par les entreprises, mais ça augmente significativement ses chances. Il contient une foule de concepts/features intéressantes : syntaxe, blocks, macros, "lecros", aspects, introspection... La documentation est particulièrement riche et bien faite.

Ola Bini, son développeur principal, est un blogger assidu et un passionné des langages de programmation : il est possible de suivre les étapes de réflexion et de construction de Ioke, et bien d'autres choses sur son blog. C'est assez enrichissant.

Exemple de "99 Bottles" (oui, on dirait vraiment du Io...) :

Potion

L'un des derniers projets de Why's the Lucky Stiff s'appelle Potion. Comme d'habitude avec ce hacker, il s'agit d'un petit OVNI. Potion est un tout petit langage, qui se veut rapide, orienté "objet et mixin".

Sa machine virtuelle fait à peine 4000 lignes de code, en C. Il faut croire que c'est une obsession pour _Why de réduire au maximum la taille de tout code : Shoes pour la GUI et Camping comme micro-framework web en Ruby, ou Yown en Io. Une bonne partie de Potion est inspiré par Lua.

La syntaxe est assez particulière, et le langage s'appuie sur l'approche suivante :

Tout est un objet
Même les mixins sont des objets
Et bien sûr, les fermetures sont des objets
CEPENDANT, les objets ne sont pas tout : ils ne sont rien sans les mixins.

Les objets n'ont pas de classe : les données (attributs) sont au niveau de l'objet lui-même, et les méthodes sont conservées dans des mixins. Tout objet possède par contre des mixins.
Je n'ai pas encore testé Potion, n'ayant pas réussi à le compiler sous Windows. On va le tenter prochainement sous 'nix, ça a l'air vraiment marrant...

Exemple de Fibonacci récursif :

Tinyrb

Plus qu'un langage à proprement parler, Tinyrb est une toute nouvelle machine virtuelle pour le langage Ruby. Elle s'annonce comme la plus petite VM du langage, mais aussi comme étant plus que raisonnablement rapide. Il s'agit pour l'instant d'une version "allégée" du langage Ruby : tout code Tinyrb tournera avec un autre inerpréteur Ruby, mais l'inverse n'est pas vrai (il manque notamment un certain nombre de classes du core standard de Ruby) .

Marc-André Cournoyer a lancé ce projet en s'inspirant de Lua (encore !), Potion (tiens donc !) et Tinypy. Ici, comme pour Lua, l'aspect intéressant, c'est le côté portable et embarquable. C'est un côté de plus en plus présent dans les langages récents (Lua, Io...)

Comme pour Potion, je n'ai pas encore réussi à compiler la VM sous Window$ : à retenter aussi sous Linux... Pas de code ici, c'est du Ruby, pas plus (mais un peu moins).

~~~~

Voilà, n'hésitez pas à jeter un coup d'oeil à ces "petits" projets, et bon hack !

NOTE : les images de cet article sont libres/dans le domaine public et liées aux projets associés, hormis celle employée pour Potion , qui est l'avatar actuel de Why's the Lucky Stiff, et qui lui appartient.

Expatriation et Microblogging

2009-02-14T20:20:00.003+01:00

Expatriation

Pour la première fois de ma, colossale, vie de blogger, je viens de publier un article dans un autre blog que celui-ci : L'autre instrument du Blues, chez Lefty, à propos de l'harmonica... en Blues.

Pourquoi ?

D'abord, parce que c'est Lefty qui me l'a demandé (et qu'on ne refuse rien à "Mickey le gaucher dit La corde"). Ensuite parce que ça me gênait de parler de musique de façon aussi spécialisée sur ce blog, sachant que ça n'a strictement rien à voir avec mes "sujets habituels" (même si ça peut être assez large, je reste plutôt ciblé sur le monde de la programmation, du web, du logiciel libre... bref plutôt informatique et sciences malgré quelques écarts qui restent dans la geekerie ordinaire). Sans aller jusqu'à dire que j'aurais déstabilisé mon (immense) public, ça n'était pas très logique.

Il n'est pas du tout exclus que cette expérience continue (c'est à dire que je publie d'autres articles sur la musique dans les Chroniques de Lefty) voire même que je l'étende à d'autres sujets, qui sait ? Pourquoi pas par exemple un article sur le BHM par exemple ? Même si nous avons plus ou moins la même cible au départ, je ne détesterais pas participer à leur série sur les paradigmes de programmation... (si j'ai le temps, sur les langages stack-oriented).

J'ajoute un encart "Copinage Honteux" qui manque un peu sur ma colonne de droite...

Microblogging

Vous avez peut-être remarqué que j'utilisais la fonction de partage de Google Reader comme un Tumblelog (ici), ou que je m'étais mis à Twitter... J'avoue qu'après avoir pas mal critiqué ce genre d'outils/pratiques, à l'usage (avec un peu de temps libre aussi, il faut bien le dire...), c'est assez addictif. Twitter me semble ouvrir des voies très intéressantes dans la façon de communiquer, mais j'avoue que ça reste assez "gadget" à mon niveau (encore que...).

En bref, si vous êtes absolument fascinés (si si, vous l'êtes !) par ma vie, mon oeuvre et mon cµl (ou du moins ce qu'il en reste...), vous pouvez vous abonner à ces flux.

J'en profite pour signaler que j'ai récemment mis à jour ma liste de blogs Ruby. Je vais probablement bientôt faire une autre page de ce type pour les blogs de programmation autre que sur le Ruby que je suis.

Atlas du monde réel

2009-02-08T09:02:00.007+01:00

Il y a de nombreuses façons de représenter le monde qui nous entoure. Traditionnellement, un carte représente le monde en tant qu'espace "physique" (ou plus exactement, une de ses projections) le plus fidèlement possible en termes de surfaces et distances.
Un cartogramme tente lui de représenter le monde en fonction d'une variable donnée : PIB d'un pays, densité de la population, taux d'accès à une ressource, etc. Pour ce faire, il déforme les surfaces et les distances réelles proportionnellement à la variable qu'il exprime. Cette technique est relativement récente : inventée durant le XIXème siècle, elle n'est fréquemment utilisée que depuis la seconde moitié du XXème. Par exemple, ci-dessous, la répartition des destinations touristiques dans le monde (où l'on peut voir que la France, l'Espagne et l'Italie apparaissent bien plus volumineuses que sur une carte classique de par leur forte attraction touristique). De nombreux cartogrammes sont consultables en ligne sur le site WorldMapper.

L'Atlas du monde réel (chez l'éditeur) propose avec 366 cartogrammes une représentation originale et souvent très efficace du monde, sur des problématiques très diverses (économiques, politiques, ressources, sociologiques, médicales, culturelles, etc...).

L'une des très grandes qualités de cet ouvrage (hormis sa présentation très claire et agréable) se cache derrière la méthode employée pour la génération de ses cartes. En effet, il s'agit d'une méthode numérique récente (2004) développée par Michael Gastner et Mark Newman (coauteur de l'ouvrage et chercheur numéricien à l'université du Michigan).
Cette méthode se base sur le phénomène physique de la diffusion (mécanique des fluides/thermique) : les territoires représentés se déforment comme s'il s'agissait de ballons contenant du gaz (la variable étudiée) avec des zones de pression (les zones de fortes densités de population, le plus souvent). Article de référence : Diffusion-based method for producing density equalizing maps, Michael T. Gastner and M. E. J. Newman (PDF).
D'un point de vue purement numérique, l'équation de la diffusion est résolue par une transformée de Fourrier rapide (FFT) et intégrée par une méthode de Runge-Kutta d'ordre 4. Selon les auteurs, une précision à 1.0E-4 (cela peut paraître décevant, mais une précision plus grande n'est quasiment pas observable humainement) est obtenue en peu d'itérations (ordre de temps de calcul : quelques minutes sur un ordinateur de bureau).

Ce qui m'a paru intéressant dans cette méthode, c'est l'application d'un problème de physique (la diffusion/mécanique des fluides) à un contexte tout à fait décalé (cartographie/représentation des données). Dans l'article cité plus haut, sont listées les précédentes méthodes de génération de cartogrammes, dont une autre consiste en une analogie physique avec l'élasticité des matériaux (mécanique solide déformable).
Dans d'autres domaines, pour ce type d'analogie, on peut citer l'utilisation de méthodes de CFD (calcul en mécanique des fluides) dans des calculs de trafic (routier ou autre) ou en finance ("flux" monétaires...).

Références :

Autres liens en vrac à propos des cartes :

Le Dessous des Cartes (l'émission)
Les Atlas du Dessous des Cartes (1 et 2)
Cartes satiriques de la Ière Guerre Mondiale

Note : le cartogramme présenté ci-dessus est tiré de l'"Atlas du monde réel" et appartient à ses auteurs.

Sortie de Tabz Converter

2008-12-24T16:47:00.006+01:00

Allez hop ! Pour les fêtes, je vous propose une petite application de bureau que j'ai codée récemment : Tabz Converter. Il s'agit d'un petit logiciel libre (licence BSD) avec interface graphique permettant de convertir des partitions musicales au format texte, d'une notation vers une autre. Il est surtout orienté vers les partitions d'harmonicas, ce type d'outil existant déjà pour la plupart des instruments plus répandus (guitare, etc...).

A quoi ça ressemble ? Comment ça marche ?

Il s'agit d'une application toute simple : 2 petites listes déroulantes pour choisir les notations de départ et d'arrivée, à choisir parmi les suivantes :

Solfège
Notation Américaine
Harmonica chromatique (12 trous en Do / accordage standard)
Harmonica diatonique (10 trous en Do / accordage Richter standard)

Ensuite, il suffit de taper sa partition dans l'edit box de gauche, appuyer sur "Convert", et le résultat apparaîtra dans l'edit box de gauche (dans laquelle il peut être copié et/ou modifié). La syntaxe pour les partoches est la suivante :

Un petit bouton "Help" permet d'ouvrir une fenêtre d'aide avec le détails des syntaxes utilisées, avec exemples.

Comment l'installer ?

Cette application est basée sur Shoes (et donc implémentée en Ruby) : l'application ne nécessite donc pas d'installation en elle même, cependant pour la faire tourner il faut avoir préalablement installé le programme Shoes. Celui-ci est disponible librement sous la plupart des plates-formes connues à cette adresse :

http://shoooes.net/

Tabz Converter lui-même est disponible dans la Shoebox (un répertoire de petites applications pour Shoes - quitte à installer Shoes, essayez en quelques unes, certaines sont très rigolotes...) à cette adresse :

Tabz_Converter

Sous forme de .zip ou .rar. Une fois décompressé, il suffit de lancer le fichier tabz_converter.rb avec Shoes, et l'application se lance (shoes tabz_converter.rb via un terminal sous Windows comme sous Nix).

La suite ?

Je vais tenter d'améliorer ce petit programme régulièrement (l'utilisant moi même de façon conséquente). Parmi les améliorations fortement envisagées pour l'avenir, on peut trouver la prise en compte des altérations pour les harmonicas (overnote, bend, etc...) et un moyen (boutons "+"/"-") de monter/descendre d'une octave sur les partitions où cela est possible (pas pour l'harmonica diatonique donc).

Tout commentaire, suggestion ou rapport de bug est le bienvenu, via cet article, la page de l'application dans la Shoebox voire même par mail (cf. page de profil).

~=o=~

Bonnes fêtes à tous.

Notations...

2008-12-23T22:59:00.006+01:00

Il existe différentes façons de présenter les expressions mathématiques, les définitions de fonctions ou encore du code informatique. Juste pour l'exemple, sur l'expression [(5+1)*7 = 42] voici les 3 notations les plus courantes en programmation :

La notation infixée est la plus courante. C'est celle que l'on utilise la plus généralement tant en mathématiques qu'en programmation (j'entends par là, dans la majorité des langages...). Les opérateurs se placent entre les opérandes.

La notation préfixée place l'opérateur avant les opérandes. On la retrouve dans des langages tels que LISP ou Scheme. Même si elle peut paraître assez peu intéressante sur cet exemple, elle présente un grand intérêt : ne pas limiter un opérateur à seulement 2 opérandes. Par exemple [1 + 2 + 3 + 4 = 10] peut s'écrire plus succinctement [(+ 1 2 3 4)].

Enfin, la notation postfixée (ou Polonaise inversée) place elle les opérateurs à la suite des opérandes. Celle-ci est quasi-systématique dans les langages concaténatifs tels que Forth, Factor, Joy ou Cat (dont on devrait reparler ici très prochainement...). Vous remarquerez son absence de parenthèse : c'est son idée de base.

3 petits Reddits

2008-12-14T15:00:00.006+01:00

Petit post publicitaire pour présenter à ceux qui ne connaissent pas Reddit, et 3 petits sub-reddits sympathiques.

Reddit est un site de "social news" ou de "social bookmarking", assez proche de Digg (l'aspect réseau social en moins), ou Scoopeo en Français (moins orienté "news" cependant) : son contenu consiste en une liste de liens proposés par la communauté des internautes, mise à jour en permanence. Afin de trier les liens par sujet, il existe de nombreux "sub-reddits", spécialisé dans un genre ou un thème donné. Parmi les plus connus de ces sub-reddits, on retrouve Pics, Politics, Technology, Science, Programming, Ruby, WTF (What The Fuck ? : C'est quoi ce bordel ?) ou encore NSFW (Not Safe For Work : pour du pOr|\|0 et autre...). Depuis plusieurs mois, il est possible de créer gratuitement ses propres sub-reddits, publics ou privés, sur des sujets de son choix, et ce, assez facilement.

Au niveau de l'utilisation, le principe est très simple. Vous pouvez proposer un lien qui vous a plu (ou pas d'ailleurs...) à l'un des sub-reddits. Ensuite, ce lien apparaitra dans la liste des nouveaux liens soumis. A partir de ce moment, les autres redditeurs pourront voter pour ou contre ce lien, le commenter et éventuellement le reporter en cas d'abus (par exemple si vous postez un lien prOn dans le reddit des trucs mimi). Si votre lien obtient un accueil favorable, il pourra éventuellement passer en première page.
Pour encourager les redditeurs, il existe un système de points appelés "points de karma". Ils sont supposés représenter le respect que vous doit la communauté en fonction de votre attitude : liens soumis appréciés, bons commentaires, etc... Sans être un but en soi, ils donnent un aperçu de l'activité de chacun sur le site.

Parenthèse pour les hackeurs, le code de Reddit est libre et donc disponible pour chacun. Au départ codé en LISP, il est désormais principalement implémenté en Python (sources).

Cependant, comme beaucoup de sites "web 2.0" reposant majoritairement sur l'activité de sa communauté, il est soumis à divers problèmes. Notamment, il est très difficile pour un sub-reddit de survivre si sa communauté n'est suffisament active, ou, tout simplement, nombreuse (ce qui est souvent le cas pour des sujets très spécifiques). De même, étant un site international, c'est l'Anglais qui domine très largement les autres langues (même s'il existe quelques reddits spécifiquement dans d'autres langues...). Il est d'ailleurs amusant de constater une certaine "animosité" à l'égard de liens dans certaines langues (dont le Français) ou l'absence totale dans certaines autres (dont l'Arabe)...

Je me permets donc de vous proposer ici 3 "petits" reddits qui me paraissent intéressants :

Pixel Art :

Ce très modeste sub-reddit se focalise sur le pixel art, bien sûr, mais également sur toute autre tentaive artistique liée à 'lunivers informatique.

Blues Music :

Autre sub-reddit sympathique, mais malheureusement très peu actif, Blues Music parle bien évidemment... de Blues. N'hésitez pas à proposer vos liens !

XFCE :

Enfin, l'un des plus "spé", le reddit de l'environnement graphique XFCE. Pour info, j'ai découvert cet environnement récemment via les nouveaux netbooks sous Linux, et je dois doit dire que dans ce type de matériel, il est particulièrement efficace et agréable.

Europa

2008-12-13T00:30:00.004+01:00

"Bon, voila. Je souhaite bon courage à mon successeur Tchèque."

Non.

"Je vous prie d'accepter mes excuses pour ce qui n'a pas été accompli. L'Europe est au cœur de ce qui peut devenir la principale puissance mondiale, tant au sens géopolitique qu'au sens culturel, ou bassement économique. Je tiens à encourager particulièrement mon successeur Tchèque à la présidence l'Union Européenne. La Tchécoslovaquie a été l'un des pays de l'Est les plus développé avant l'invasion Hitlérienne. Il est naturel de reconnaître ses états fils, dont la Slovaquie, donc, avec la plus grande attention. Ainsi que les Pays-Bas, ne serait-ce que pour l'héritage de Rombrant. La Suède et le Danemark pour leur culture scandinave (L'Odinisme étant reconnu en tant que religion et non secte dans de nombreux états.). L'Espagne pour ses poètes, son histoire et ses douleurs. Le Portugal pour sa tristesse. La Finlande pour sa langue, absolument abstraite et sa musique métalo-pop merdique. L'Irlande pour notre héritage celte commun, qu'on le veuille ou non. Le Royaume-Unis, bien que ça coûte à chacun. L'Italie, et son influence antique qui a grosso-modo marqué toute l'Europe. La Grèce, à qui l'on doit le nom d'"Europe" : sordide vache catin, maitresse de Zeus. Bulgarie, Roumanie et Hongrie : états mal aimés qui portent pourtant en eux tout l'héritage, au sens large, de l'empire austro-hongrois. La Pologne, régulièrement citée comme lieu le plus sinistre au monde (après la Moldavie - et prouvant aux yeux de certains, l'existence de Dieu). L'Allemagne, véritable centre de l'Europe depuis le Saint Empire Germanique. Et les états Baltes (et non Basques...) sans cesse à la recherche de leur véritable identité, entre influence slave et délires micro-culturels finno-hougriens. Pays des balkans, whatever yo name(s), qui souhaitez sortir de cette poudrière de m3rde. Et enfin, encore, l'Italie, la trop caricaturée, qui vaut cent fois son pesant culturel et historique via le très décadent empire romain. Je ne peux bien sûr pas parler ici de la France, ni de la Belgique, qui connaissent leur rôle dans l'aventure européenne."

Voilà ce qui me semble être le le discours nécessaire d'un véritable européen objective et pragmatique. Cela dit, pour des raisons à la fois économiques et sociales, nous sommes loin d'entendre ce type de discours (pourtant fédérateur, à sa façon...) de la part des différents responsables européens.

Pourquoi ?

Changement de Design

2008-12-01T22:08:00.003+01:00

Depuis quelques temps, une immonde barre bleue non identifiée était apparue dans le corps des messages de ce blog...

Malgré mes 47 secondes d'efforts acharnés, je n'ai pas réussi à corriger ce bug, et donc par flemme profonde (et désintérêt significatif pour le HTML/CSS/XML, il faut bien l'avouer... surtout quand il est aussi crade que dans Blogger !), j'ai décidé de changer le design de ce modeste blog... en en prenant un tout-fait-tout-prêt (ou presque), déniché ici. Celui-ci étant sous licence CC avec paternité, vous avez droit à un petit lien vers le site de l'auteur inclus, mais ça reste discret.

Je disais "presque" car il manquait un bon petit nuage de tags (que je préfère généralement aux vilaines listes de libellés basques de chez Blogger), ainsi que le petit outils de traduction Google qui peut être utiles à nos amis non-francophones.

Vos avis sur le nouveau design sont les bienvenus, en espérant qu'il me motive à me remettre à poster un peu plus fréquemment !

Pourquoi utiliser Ruby ?

2008-10-31T14:27:00.005+01:00

Note préliminaire :

Il y a quelques temps, j'avais rédigé cette présentation à la demande de gars du Site du Zéro, dans le but de faire un topic de comparaison objective (Mama mia !) du Ruby et du Python. Ne connaissant que très peu le Python, je me suis chargé de la partie Ruby. Initialement rédigée en zCode, la première version de celle-ci est disponible à l'adresse suivante (à toute fin utile) : version zCode. (Merci par avance de me prévenir si vous détectez un problème dans cet article : lien mort, texte "bizarre" ou autre).

-~=.=~-

Pourquoi Ruby ?

Ruby

Ruby est un langage de programmation libre, interprété, à typage dynamique fort et orienté objet. L'écriture de ce langage d'origine japonaise a débuté en 1993 et est dirigée par différents principes :
En Ruby, toute donnée est un objet, et toute fonction est une méthode (une méthode étant elle même un objet...) : il n'existe pas de type primitif comme dans certains autres langages.

irb(main):001:0> 1.class
=> Fixnum
irb(main):002:0> Fixnum.class
=> Class
irb(main):003:0> Class.class
=> Class

Ruby est dynamique et flexible : possibilité de modifier le code à l'exécution, et/ou de redéfinir son implémentation de base.

# Exemple de modification du code natif # en cours d'execution

a = 1

puts a.class
#=>Fixnum

# to_s : methode native de conversion en String
puts a.to_s
#=>"1"

# Modification de to_s
class Fixnum
    def to_s
        "Huhuhu !"
    end
end

puts a.to_s
#=>"Huhuhu !"

Le principe de moindre surprise veut que le développeur (expérimenté, ou venant d'un autre langage) soit le moins surpris/dépaysé/perturbé possible par la syntaxe ou les mots clés de Ruby.

"Convention plutôt que configuration." Ruby favorise ce concept, très repris dans certaines applications du langage, dont Rails.

Ruby est à comparer à d'autres langages dynamiques interprétés, dont : Python, Groovy, PHP, Io, Perl et Scheme, entre autres.

Pourquoi Ruby ?

Quelques avantages :

Entièrement objet, mais autorise le procédural, et dans une certaine mesure inspiré du fonctionnel. Le développeur est donc libre. De même il y a "Plusieurs façons de faire la même chose". Cela ne veut pas dire pour autant que toutes se vaillent.

Le core et l'API standard fournissent tout le nécessaire pour débuter (et continuer !) : threads, benchmark, gestion d'exceptions, parseurs...

Grandes possibilités de métaprogrammation.

Différentes implémentations du langage sont disponibles : MRI pour la principale en C, mais aussi JRuby (en Java, pour la JVM), IronRuby (pour la plate-forme .Net), Rubinius (en Ruby) et dernièrement MagLev, et quelques autres.

La prise en main est généralement rapide pour quelqu'un ayant déjà de premières bases en programmation et en POO.

Contrairement à ce qu'on peut souvent entendre, la documentation du coeur et des librairies standards est bonne et claire. Les ouvrages traitant du langage sont également assez nombreux, et parfois de très bonne qualité. Notamment : Why's (Poignant) Guide to Ruby, le Pickaxe, Ruby par l'Exemple, Design Patterns in Ruby...

Outils associés : TextMate (pour MacOS), Aptana RadRails (pour Eclipse ?), RDoc (génération automatique de documentation), RubyGems (gestionnaire de packages, appelés "gem" en Ruby), etc...

Communauté importante et active : RubyForge.

De nombreuses gems, portages et librairies de qualité pour le web (Rails, Merb, Ramaze, Camping...), pour la GUI (GTK, WxWidgets, FOX, Shoes, tk...), pour les sciences (BioRuby, LaPack...)...

Et quelques (malheureux) défauts :

D'abord, les performances en terme de vitesse d'exécution sont assez mauvaises pour un langage de ce type. A relativiser cependant : les performances sont rarement critiques pour un langage de ce type d'une part, et d'autre part, les améliorations sont régulières sur chacune des implémentations du langage (avec une certaine compétition qui favorise les progrès).

Manque de sécurité sur certains points : peu de warnings, constantes pas constantes... Ceci est principalement dû à la grande liberté du codeur.

Métaprogrammation riche, mais incomplète (à comparer à Io pour l'introspection/réflexion notamment).
Communauté très (trop ?) orientée Rails et web. Très anglophone également.

Gestion perfectible des blocks.

Certaines parties des librairies standards contestables (Math et Matrix entre autres).

Langage "non-pur" : à comparer à Io, Smalltalk ou Scheme (encore que le Scheme ne soit peut-être pas "purement" fonctionnel...). Ici encore, c'est surtout une conséquence de la liberté du programmeur. Et en conséquence, la relative facilité pour commencer à coder en Ruby peut donner de mauvaises habitudes aux débutants (ou l'impression d'avoir rapidement fait le tour...) ; on le constate régulièrement dans des codes pour Rails ou RPG Maker XP.

Ah ! Et dernier avantage du langage : son créateur est aussi un grand comique ^^

Une tortue avec Processing

2008-09-23T21:50:00.006+02:00

J'ai découvert récemment Processing (parfois écrit Proce55ing), un langage de programmation/environnement pensé pour des réalisations "artistiques" : images, animations, sons et 'interactions'.

Basé sur le Java, la syntaxe semble assez proche du Javascript, assez concise et simple. Le typage est statique en revanche. Dans l'ensemble, c'est plutôt bien fait : la prise en main se fait en quelques petits essais... Par exemple :

Exemple (Le code)

Pour information, cet environnement est disponible sous toute plateforme, et en diverses implémentation (Javascript, Ruby...). Pour avoir un peu joué avec Shoes, je retrouve là une bonne partie de ce qui a inspiré _Why pour sa conception... L'un des côtés intéressant, outre l'environnement vraiment simplissime, c'est l'assez grand nombre de bibliothèques (3D, traitement du son et du signal, XML, Vidéo, PDF...) même si elles sont parfois un peu "orientée Mac" (QuickTime entre autre...). Notamment, Arduino et Wiring dans l'interfaçage physique, me paraissent particulièrement intéressants : avec un matos de base relativement abordable (à partir de 20€ pour les cartes), les possibilités sont très grandes... (Je vous laisse chercher.)

Allez, un petit code rigolo pour illustrer :

Turtle :

J'ai essayé de faire une petite version, assez simplifiée, du langage Logo (langage de programmation où l'on dessine avec une tortue).

Le "coeur" est implémenté dans un premier fichier "turtle_lib.pde".
La méthode setup(), comme son nom l'indique, est une méthode d'initialisation qui est systématiquement appelée (si existante) par Processing avant la méthode principale. Elle ne peut être rappelée par la suite. La fonction noLoop() indique à l'interpréteur que les instructions qui seront données par la suite n'auront pas à être répétées (par défaut, le contenu de la méthode draw() est exécuté de manière cyclique, notamment pour les animations et les captions diverses : souris, clic, etc... Ici, ceci est inutile et gênant).
Les méthodes suivantes sont les méthodes de base du Logo : move pour avancer le crayon d'un nombre donné de pixels, turn pour changer sa direction, changeColor pour changer sa couleur et son opacité, raisePen et putPen pour le lever le crayon (celui-ci n'écrit donc plus lorsqu'on le déplace) et le (re)poser, respectivement.

Voici un petit exemple d'utilisation : les instructions se trouvent dans la méthode draw() qui constitue la méthode "principale" de tout programme Processing.

Exemple de la tortue (turtle_ex.pde)

Non, ce n'est pas très joli... mais c'est de la faute à la tortue !

Références :

Processing
Tutoriel de l'école des Arts d'Aix-en-Provence
Doc de référence du langage.
Arduino
Wiring

Dans le même genre...

Shoes (Ruby)
Nodebox (Python / MacOS)
ContextFree ("proche" du C)
Et bien d'autres...

Amusez-vous bien !

Se faire plaisir pour la rentrée...

2008-09-14T22:09:00.004+02:00

Parce que parfois, se faire plaisir... ça fait plaisir...

Ceci est un PicooZ : un tout petit hélicoptère télécommandé. C'est pas très cher, assez chaud à maîtriser, sans risque et franchement marrant... Un blog avec plein de ressources, vidéos, tricks et news sur ces petits machinos.

Tiens, je crois que je n'avais pas encore parlé de jeu de plateau ici... Roma de Stefan Feld (en VF) est un jeu de carte avec dés pour 2 joueurs dans le style "stratégie conviviale" : dans la lignée de Citadelle, il associe des aspects tactiques assez simples mais parfois vicieux avec une part relativement importante de hasard qui garde le jeu assez équilibré, le tout avec des parties durant environ 30 minutes. De façon assez surprenante (pour moi) la part de chance dans ce jeu ne me paraît pas trop gênante par rapport à d'autres (Colons de Catane et Risk, entre autre) où elle peut aisément fusiller complètement une stratégie en quelques mauvaises passes. Bref, un bon petit jeu dans la tradition allemande pour 2.

Conseillé par Lefty, le dernier BB King, One Kind Favor, est un petit bijou : reprenant de bons vieux classiques de manière elle aussi classique (et peut-être limite jazzy sur les bords pour certains morceaux). On retrouve vraiment l'essence du Blues avec une combinaison chant + guitare parfaite. Un très bon album (article de Lefty sur celui-ci).

Ruby : Renommer un ensemble de fichiers

2008-09-14T21:30:00.001+02:00

Juste un petit code pour renommer un ensemble de fichiers. Sous Unix, un petit shell serait sans doute suffisant, mais étant sous Windows à la maison et n'aimant pas des masses le Batch, voici ce que ça pourrait donner... Dans cet exemple, on associe à d le répertoire dans lequel on souhaite renommer les fichiers dont le nom commence par "PICTURE_" (sortie d'appareil photo dans mon cas) en "starpics_000X" avec X s'incrémentant.


d = Dir.new("C:/Documents and Settings/utilisateur/Photos/Star")
Dir.chdir("C:/Documents and Settings/utilisateur/Photos/Star")
i = 1
d.each do |file|
  if file.to_s[0..7] == "PICTURE_" then
    File.rename(file.to_s, "starpics_000#{i}.jpg")
    i += 1
  end
end

Rien de bien méchant dans ce court code. Quelques remarques cependant : on remarque que même sous Windows, les séparateurs dans le chemin du répertoire est un slash et non pas un anti-slash... Il me semblait qu'il y avait une méthode de base pour faire cette conversion un peu pénible mais je ne l'ai pas retrouvée... Une chose un peu pénible avec cette partie du core de Ruby, sur les fichiers et répertoires, c'est que c'est assez peu homogène : ici, on itère sur les fichiers grâce à la méthode d'instance each de la classe Dir (Directory), on change le répertoire courant grâce à la méthode de classe chdir, mais la méthode de renommage de fichier est une méthode de classe ! Pourquoi pas une méthode d'instance sur sa cible ?

Au passage, il est possible de renommer plusieurs fichiers en même temps sous Windows via l'explorateur : les sélectionner puis faire F2. On en renomme un, les autres prennent le même nom, suivi de " (X)" avec X s'incrémentant. La beauté de Windows ? Des anti-slashs dans les chemins et surtout de superbes espaces et parenthèses dans les noms de fichiers...

Un bon tutoriel sur Ruby pour la partie "Manipulation de fichiers", par JB Naigeon (:fr).

Blogged with the Flock Browser

Essai de Google Chrome en Live !

2008-09-02T22:09:00.010+02:00

Après l'annonce hier de sa sortie imminente, Google Chrome, le navigateur web made in Google, est disponible depuis quelques (petites) heures en téléchargement (ici). Le géant du web diffusait déjà aujourd'hui cette BD (en anglais), expliquant par

la voix de ses développeurs l'intérêt de ce logiciel et détaillant techniquement (parfois de manière assez poussée !) ses caractéristiques diverses.

Après mon dernier article sur le navigateur orienté social Flock, je ne résiste pas à vous refaire le coup du post écrit en live depuis ce nouveau browser.

De l'importance de la première impression...

Ce qui saute aux yeux à l'ouverture du soft, c'est la sobriété et la clarté de l'interface. Comme sur la plupart des applications Google (je pense surtout à Gmail et Google Reader), c'est une réussite : du bleu clair et du blanc, des icônes claires et populaires, etc... Le design de l'interface est entièrement tourné vers l'onglet, et non pas vers la fenêtre. Pour celle-ci, on oscille entre un visuel rappelant la dernière version de GTK, et l'interface de Windows Vista... pour le peu qu'on la remarque ! En effet, et comme annoncé, ce sont les onglets qui gouvernent ici, et donc, ceux-ci atteignent le haut de l'écran, un peu comme en mode plein écran sur d'autres navigateurs.

La barre principale est minimaliste, dans un style rappelant assez Safari : 4 boutons, la barre d'adresse et 2 icônes de menu déroulant ("contrôler la page actuelle" et "personnaliser et contrôler Google Chrome"). Même la barre de favori en dessous peut être enlevée (on y retrouve en coin le dossier des favoris sous forme de menu déroulant). Tout à manifestement été fait pour que l'on oublie le navigateur lui même : clairement, on ne voit que sa page web.

Au niveau de l'affichage, c'est WebKit, le moteur de rendu utilisé par Safari (et dérivé du KHTML de Konqueror) qui est utilisé. J'avoue être très agréablement surpris par les progrès de celui-ci... même si c'est un peu déstabilisant lorsqu'on est "trop" habitué au moteur Gecko (employé par Firefox).

Oh, et un détail : il n'y a pas de panneau latéral !

Vite vite ?

Au démarrage, Chrome va vite. Chez moi (c'est important), il est à priori plus rapide que Flock (équivalent à un Firefox 2 dernière version avec quelques extensions) et plus rapide que Firefox 3... Au chargement, c'est assez difficilement mesurable à l'oeil nu, et surtout, ça me paraît plus "variable" qu'avec mes autres navigateurs (hormis peut-être Opera...) : sans doute un poil plus long, mais à faire vérifier par de vraies mesures. Par contre, le navigateur est impressionnant pour le javascript : Gmail et Google Reader (tiens des applis Google, comme par hasard...) sont extrêmement rapides (si vous n'êtes pas convaincus, à tester sur cet interpréteur online de Brainfuck... qui n'a pas été codé par Google...).

Au niveau de la consommation mémoire, chaque onglet est un processus séparé. Pour résumer pour les moins informaticiens d'entre nous, c'est à dire qu'ils se comportent comme étant chacun "un programme à part" : notamment, si l'un d'entre eux bugge, le programme dans son ensemble ainsi que les autres onglets continuent de fonctionner. Cela veut également dire que l'on peut surveiller la conso de chaque onglet : le programme propose un gestionnaire de tâches séparé de celui de l'OS ainsi qu'une page spéciale about:memory afin de gérer sa consommation.

A titre purement indicatif, sur ma modeste bécane (avec les mêmes pages ouvertes bien sûr mais probablement avec des différences de cache) :

Chrome : 131 M
Firefox 3 : 97 M
Flock 1.2.4 : 115 M

Chrome est donc encore assez loin des efforts de Mozilla pour diminuer la consommation mémoire.

J'ai par ailleurs l'"impression" que l'intégration du Flash est d'avantage réussi que dans mes autres navigateurs... Illusion d'optique ?

Clarté et Opacité

Parmi les exemples et fonctionnalités qui font la clarté de Chrome on a une barre d'état... inexistante : celle-ci apparaît uniquement au besoin, pendant le chargement d'une page ou lorsque l'on passe sur un lien. La barre d'adresse met également en relief le nom du site plutôt que l'adresse complète de la page courante. Les options sont également très claires. Et les principaux raccourcis de Firefox fonctionnent... La page d'acceuil est une sorte de Fast-Dial en mieux : il propose les pages les plus visitées par l'utilisateur mais aussi les favoris récents ou encore d'afficher l'historique : très bien conçu.

Cependant, certaines fonctionnalités me paraissent d'un accès assez difficile, comme le gestionnaire de tâches, le passage en mode "navigation privée" ou encore le gestionnaire d'extensions/plug-ins (pas trouvé). Par certains côté, Chrome me rappelle beaucoup les produits Mac de par son "opacité" sur les fonctions les moins employées par les utilisateurs (demandez donc à un Mac-User basique d'ouvrir un terminal et un éditeur de texte...).

Et Tic et Tac ?

Fini le live, parlons éthique... Ou plutôt, posons-nous quelques questions...

Est-il raisonnable d'utiliser un navigateur produit par l'entreprise leader (incontestée) du web ?
Quel est l'intérêt pour Google de financer ce navigateur ?
Celui-ci intègrera-t-il une forme de publicité ? (autre que pour la marque Google en elle-même)
Google finançant la fondation Mozilla, qu'en est-il de l'avenir des relations entre ces 2 entités ?
Faut-il craindre l'avènement du Big Browser ?
Si Google Chrome est open-source, n'est-ce pas en partie pour favoriser l'adoption des technologies "Google-made" par les autres grands acteurs du monde libre (Mozilla entre autres) ?
Quid du service de mise à jour de ce navigateur ? (élément de sécurité critique)
Quel sera l'impact de cette nouveauté sur le marché des navigateurs web ?
Qui vise Google ? Microsoft et/ou Mozilla ? (et/ou Apple ?)
Chrome ne sera-t-il que le navigateur d'Adroid ? (pour téléphones portables)
Pourquoi Chrome n'est-il disponible que sous Windows !!!? (pour l'instant...)
Où sont les extensions et les plug-ins ?
Juste un buzz ?

A chacun de répondre, pronostiquer et choisir.

Conclusion

Google Chrome est prometteur. Tous les paris ne sont pas encore gagnés pour lui, loin de là : performances, consommation mémoire, ouverture, sécurité et maintenance... Cependant, sa conception relativement neuve (relativement car WebKit n'est pas non plus une révolution...), ses objectifs techniques et son originalité lui assureront inévitablement des adeptes. Cela suffira-t-il a changer significativement la donne dans le marché des navigateurs web, toujours (mais de moins en moins) dominé par Internet Explorer ? Rien n'est moins sûr... mais c'est Google, on ne sait jamais...

Par ailleurs, il soulève bien des interrogations, et même des inquiétudes, notamment dans le monde du libre. Sans sombrer dans la paranoïa et la suspicion pour toute société possédant plus de 4$, il est nécessaire de continuer à rester prudent vis-à-vis des pratiques de Google.

Ressources :

Note : Les images de cet article appartiennent à leurs propriétaires respectifs.

Essai de Flock en Live !

2008-08-19T23:38:00.001+02:00

Ceci est un essai de l'éditeur de post du navigateur web Flock. Celui-ci est un dérivé de Firefox orienté "Social", c'est à dire disposant de nombreuses fonctionnalités pour les sites dits sociaux ou web 2.0 tels que les blogs, réseaux sociaux, "social bookmark", partage média et autres...

Commençons par ce que j'ai entre les doigts... Je découvre avec vous, en live !

L'Editeur

Déjà, l'éditeur (qui se présente dans une fenêtre séparée) propose d'ajouter un titre et un texte alternatif avec chaque image : c'est un bon point par rapport à l'éditeur de base de Blogger (mais pourquoi n'ont-ils pas fait de même pour les liens !!!?). Il comporte 3 onglets : "Editor", "Source" et "Preview", consultables en permanence. L'aperçu est très pratique, par contre je regrette qu'il n'y ait pas de coloration syntaxique sur les sources...

Cette dernière image a été ajouté directement via le "Web Clipboard" : du drag-N-drop d'un objet quelconque (texte, image, lien...) vers celui-ci et cet objet devient accessible directement pour le blogger ou le mailler, ou l'insérer dans un post en cours de rédaction... Pas mal.

Pas de récupération des tags (libellés) déjà utilisés depuis Blogger cependant. Dommage. Pas d'upload direct d'image depuis l'éditeur non plus... mais l'upload d'image constitue un outil à part entière du navigateur (voir plus loin).

La gestion de différents comptes de blog sur différentes plate-forme semble assez aisée.

Le Navigateur

Le navigateur en lui-même est assez agréable : très proche de Firefox évidemment, mais plus chargé, et avec un design de base assez moderne et ma foi agréable. Un grand nombre de favoris est déjà présent parmi les "applis sociales" : webmail divers, la plupart des plate-formes de blog, les réseaux (Facebook, etc...), les bookmarkers (Digg, Delicious, magnolia) et les médias (Youtube, Flickr, etc...). Peu d'add-on semblent cependant disponibles... rien pour reddit notamment.

Les fonctionnalités ont l'air plus ou moins utiles :

MyWorld semble être un compromis entre une page personnalisée (iGoogle ou NetVibes par exemple) et un Speed Dial à la Opera.

La People sidebar permet, après s'être loggé à son réseau social fav... bref, Facebook (ou Hi5 pour les Sud-Américains, c'est-à-dire pas pour les mecs de Blois...). Elle permet, donc d'avoir sous la main tous ses contacts : accès aux actions de base (message, wall, accès profil, etc...) et "flux média" (les photos quoi...). PLUS des notifiers pour les requêtes principales (mail, friend request, event, etc...). Pratique pour jeter un oeil sur ses contacts sans passer 2H sur site...

La Media Bar, elle, propose d'afficher en haut de page, sous forme de liste déroulante de vignettes, les "objets" en provenance d'un flux donné. Celui-ci peut être les images les plus vues de Flickr, une chaîne Youtube, les photos de ses amis sur Facebook, des images de news d'un site d'info ou autre. Pas mal.

La Feed Sidebar est un simple aggrégateur de flux RSS, Atom, etc... Plutôt sommaire, mais avec possibilité de créer des sous-dossier (par thème par exemple).

Le bouton Webmail est comparable au bouton Gmail de la barre d'outil Google pour Firefox. Pas bien plus mais ça marche.

La barre de favoris est déjà bien pleine : Facebook, Digg, Flickr, Photobucket, Delicious, etc... Elle est cependant scindée en 2 avec une partie "online" proposant d'accéder à et/ou partager ses favoris en ligne grâce au service de Flock. Mwooof.

Plus utile la barre Accounts and Services donne l'état de connexion/disponibilité de l'utilisateur sur les différentes applis supportées. Très utile en fait...

Il y a également un bouton pour le Web Clipboard que j'ai utilisé tout à l'heure. En image, dans la barre latérale :

Enfin, il reste un bouton pour ouvrir l'éditeur de blog et un autre pour l'uploader de photos (Facebook, Picasa, Flickr, etc...). Extrêmement pratique dans les 2 cas.

Conclusion

Sincèrement, je suis assez surpris. Flock est très agréable et d'une grande facilité de prise en main, pour peu que l'on soit habitué à Firefox (et encore...) : de nombreux petits messages d'aide (discrets) apparaissent au fur et à mesure de l'utilisation pour faciliter la configuration des différents comptes et autres options. Painless. Au niveau navigation et options associées, c'est du Firefox, ni plus, ni moins. C'est clair, visuellement réussi, et assez ergonomique. Par ailleurs, l'installation se fait, "évidemment", avec l'importation des données de votre autre (vos autres...) navigateurs.
On peut trouver qu'il y a "trop" de choses useless. Par exemple, je n'utilise pas Digg, ni Flickr, ni un paquet de sites du genre : du coup beaucoup de raccourcis, et widgets me sont inutiles. Qu'à cela ne tienne, ils sont supprimables.
Pour ce qui est de l'intérêt d'un tel navigateur par rapport à Firefox (ou Opera voire Safari)... La question se pose clairement, étant données la qualité et le degré de customisation de ce(s) navigateur(s). Cela dit, pour une utilisation très "sociale" du web, Flock me semble très adapté. Ses aspects gadgets sont le reflet même de ce type d'utilisation du web : à chacun son utilisation des blogs, des réseaux sociaux et du web en général.

Liens :

Blogged with the Flock Browser

Medicolor : le code

2008-08-19T19:34:00.002+02:00

Je viens de me rendre compte que j'ai oublié de publier le code de Medicolor : mon petit programme fait avec Ruby et Shoes générant les images de 2 articles précédents... Honte à moi ! Donc, basiquement, Medicolor est une petite appli manipulant les couleurs : à partir d'un pattern de départ (et les conditions aux limites associées), le programme moyenne à chaque itération (déclenchée par un simple clic dans la fenêtre) les couleurs de chaque disque présent avec celles de ses voisins.

Pas clair ? Vous pouvez l'essayer à partir des sources (nécessite Ruby et Shoes version r751 ou suivante).

Les sources

En ligne de commande : $>shoes shoes_medicolor.rb

Le nom du fichier d'entrée (medicase_01.rb par exemple) peut être directement changé dans le require. Les conditions aux limites sont périodiques ou fixées, les points peuvent être également de couleur fixe (voir cas d'exemple avec les sources).

Amusez vous bien !

Tumblelog

2008-08-13T19:21:00.003+02:00

En général, j'essaie d'éviter de "metablogger" (blogger au sujet de mon blog, ou du fait même de blogger). Mais une fois n'est pas coutume...

Les quelques courageux qui suivent ce blog régulièrement auront sans doute constaté que malgré mes efforts, ma fréquence de publication a pour le moins "baissé" depuis quelques mois. Plus de travail, moins de temps libre, etc... Donc, moins de temps pour écrire des articles "corrects".
Cependant, il y a une solution pour partager rapidement des liens, articles et infos intéressantes : un tumblelog.

Sur le principe, un tumblelog est comparable à un blog, mais avec des billets très courts : de simples notes ou liens, en général sans commentaires. Entre la page de partage et le flux de liens, avec un contenu souvent plus divers qu'un blog classique. Il semblerait que le terme ait été introduit par Why The Lucky Stiff, hacker ruby populaire. Attention à ne pas confondre avec le Microblogging qui consiste à partager sous forme de courts tickets les instants passionnants de sa vie (cf. Twitter et autres sites buggés...).

Et il se trouve que j'utilise la page de partage de Google Reader comme Tumblelog à cette adresse, les derniers articles apparaissant dans la colonne de droite de cette page. Par rapport à ce blog, la fréquence de post est bien supérieure et les sujets plus variés (programmation bien sûr, mais aussi design, art, BD, jeux...).

Pour le principe, j'ajoute ici une liste de tumbles et pages de partage que je suis, en vrac :

A Rubyist Railistic Adventure par Juixe (ruby, rails...)
fr4nc1s0ud's sharez items par B. Francisoud (programmation, web, cinéma, autre...)
Happy Coder's Daily Digest par Juixe (programmation, web...)
Future Perfect (photo, design, asie...)
Lemonodor Auxiliary par un homme faisant du LISP (photo, art, geek...)
PixelBot (pixel art...)

Au passage, j'en profite : j'ai "nettoyé" ma colonne de droite : plus de pub, moins de liens useless. J'ai également ajouté un bouton reddit en bas d'article pour ceux qui utilisent cet outil (on en reparlera...). Bonne lecture.

Classe Struct en Ruby

2008-08-06T23:00:00.004+02:00

Je suis récemment tombé (par hasard, pour changer...) sur une classe de Ruby pour le moins rare : Struct. Basiquement, il s'agit d'une classe permettant d'implémenter rapidement des conteneurs simples, et fixés. Par rapport à un Hash, il n'est possible que de passer des symboles comme clefs, et il n'est pas permis d'ajouter de nouvelles clefs après déclaration. Struct possède également moins de méthodes que Hash, mais conserve les plus importantes (celles héritées d'Enumerable).

J'avoue être assez surpris par l'existence de cette classe. D'une part, parce que je ne l'ai rencontrée dans aucun code Ruby. Jamais. Ensuite parce qu'elle semble assez peu intéressante par rapport à un hachage (hormis pour l'aspect "déclaré" et "fixé" de ses clefs). Enfin, parce qu'elle n'apporte pas à priori de meilleures performances qu'un hachage (car elle est implémentée avec... eh voui...).

Deux liens sur cette classe :

Documentation Struct
Article chez NutRun

Enfin, encore un côté surprenant, les clefs d'une structure ne semblent pas en être des attributs...


Fiche = Struct.new(:nom, :prenom, :adresse, :phone)

# Exemple d'initialisation
roger = Fiche.new "Dupont", "Roger", \
                  "3 rue des Lilas, \
                  55555 Canardville", \
                  "0800555222"

p roger
#=> #struct Fiche nom="Dupont", prenom="Roger", 
#        adresse="3 rue des Lilas, 55555 Canardville", 
#        phone="0800555222">

chuck = Fiche.new

chuck.prenom = "Chuck"

puts chuck.prenom
#=> Chuck

class Fiche
  def foo
    puts @prenom

  end
  
  def bar
    puts self.prenom
  end
end

chuck.foo
#=> nil

chuck.bar
#=> Chuck

Medicolor : 2

2008-08-05T20:40:00.006+02:00

Medicolor : 1

2008-08-04T22:48:00.009+02:00

Forgotten Ruby methods

2008-07-28T22:34:00.005+02:00

Ou plutôt les méthodes que je n'utilise pas assez... Sur les tableaux, les chaînes de caractères et quelques autres petites choses très mignonnes comme l'opérateur ternaire, l'affectation multiple (à consommer avec modération...) et le ||. 21 autres choses très intéressantes dans cet article.

Petit mot sur la méthode extend : d'un point de vue POO, elle permet en quelque sorte "d'instancier un module". Si une classe étend un module Mod, les "méthodes d'instance" de celui-ci seront transmises à la classe en tant que méthode de classe. Si l'on étend Mod avec un simple objet (bon, d'accord, une classe est un objet... mon explication précédente reste valable.), celui-ci se comportera comme une instance de Mod, avec les méthodes qui vont avec... Deux bonnes sources sur le sujet : [Ruby's Cube, :fr] et [Juixe TechKnow, :en].

### Multiple affectation  and || ###
a, b = nil, 10
#=> [nil, 10]
a || b
#=> 10

### On Arrays... ###
a = [0,"111",2,3,3,3,3]
a.class
#=> [0,"111",2,3,3,3,3]
a.delete 3
#=> 3
a
#=> [0,"111",2]
a.delete_at 1
#=> "111"
a
#=> [0,2]
a.insert(1,"1")
#=> [0,"1",2]
a += [3,4,5]
#=> [0,"1",2,3,4,5]
a.inspect
#=> "[0,\"1\",2,3,4,5]"
a.map!{|v| (v.is_a? Numeric)? v : v.to_i}
#=> [0,1,2,3,4,5]
a = a.join "-"
#=> "0-1-2-3-4-5"
a = a.split '-'
#=> ["0", "1", "2", "3", "4", "5"]
a | ["1", "6", "7"]

#=> ["0", "1", "2", "3", "4", "5", "6", "7"]


### And Strings... ###
str = "  trop d'espace tue l'espace...      "
#=> "  trop d'espace tue l'espace...      "
str = str.strip
#=> "trop d'espace tue l'espace..."
str.crypt "Oz" # "Oz" est le 'sel'
#=> "Oz2SDpLQ4HL02"
str.count "e"
#=> 5

### Finaly, the Object#extend method ###
module Mod
    def homerize
        p "Doh!"
    end
end

class Simpson
    extend Mod
end

Simpson.homerize
# "Doh !"
#=> nil

bart = Simpson.new
# bart can't homerize, unless...


bart.extend Mod
bart.homerize
# "Doh !"
#=> nil

Algorithme Rho de Pollard en Ruby

2008-07-24T20:17:00.003+02:00

L'algorithme Rho de Pollard permet de décomposer un entier en son produit de facteurs premiers. Cet algorithme se base sur une fonction dite aléatoire f, permettant d'obtenir une suite cyclique :

xi+1 = f(xi) % n

avec n l'entier à décomposer.

Attention, si :

pgcd(|xi - x2i|, n)

prend n pour valeur, l'algorithme produit une boucle infinie (il faudrait (y a qu'à...) alors changer la fonction f ou aller se faire cuire un steak de soja) : dans mon code, je lève une erreur, en l'occurrence.
Sinon, beaucoup de récursion...

Code prime.rb :
(Ruby 1.8.6 : $ prime.rb [integer])

def pgcd m, n
(n==0)? m : pgcd(n, m%n)
end

def f x, n
(x**2 + 1) % n
end

def x i, n
(i==0)? 2 : f(x(i-1,n), n)

end

class Integer
def is_prime?
    res = true
    if self < 2 then
        res = false
    else
        for i in 2..Math.sqrt(self).to_i
            if i.is_prime? and (self%i == 0) then
                res = false
            end

        end
    end
    res
end
end

def pollard n
r = []

if n.is_prime?
    r.push n
elsif n != 1
    i, p = 0, 1
    while p == 1
        i += 1
        p = pgcd((x(i,n)-x(2*i,n)).abs, n)
    end

    raise "Pollard Algorithm: Cycle FAIL" if p==n

    if p.is_prime? then
        r.push p
    else
        r.push pollard(p)
    end

    r.push pollard(n/p)
end
r.flatten!
r
end

input = ARGV[0].to_i
pollard(input).each {|x| puts x}

Ruby : Plus ou Moins en moins de 100

2008-07-22T22:29:00.009+02:00

Suite à cet article rigolo (tiré d'un blog tout à fait intéressant au passage), essayons de faire le jeu du "Plus ou Moins", en Ruby avec le moins de caractères possibles...

Code :

n=(100*rand).to_i;loop{d=gets.to_i;(d==n)?(puts "bravo !";break):puts((d>n)?"lower":"greater")}

Désolé, ça dépasse encore un poil... (ctrl ou pomme + molette)

95 caractères donc... mais pas top lisible. Je regrette surtout que ce ne soit pas "vraiment" en une ligne (objectivement, là, il y en a 3), mais on ne peut pas tout avoir...

Dummydgets pour Shoes : Bulles

2008-07-17T22:34:00.012+02:00

Allez hop, deux petits programmes profondément inutiles faits avec les pieds, pour Shoes. Dans ces deux là, j'utilise le bloc motion{} qui permet d'effectuer une action en fonction de la position courante du curseur. La syntaxe est la suivante :

motion do |x,y|
 foo(x)
 bar(y)
 foobar(x,y)
    # etc...
end

Dès lors, le code contenu dans ce block (ici les méthodes foo, bar et foobar) sera exécuté dès que la position du curseur (désignée par x et y) change. Attention, l'axe Y est dirigé vers le bas (il serait plus rigoureux d'écrire |left,top| plutôt que |x,y|).

J'utilise aussi la méthode move(x,y) qui permet... de déplacer sa cible à la position (x,y). Easy, isn't it ?

Bubbles

Dans celui-ci, la fenêtre contient une dizaine de bulles qui se déplacent selon des fonctions plus ou moins complexes qui donnent une impression assez "chaotique"... mais en fait non.

Bubbles (pointeur non-représenté)

Le code est disponible ici, et l'image de fond ici (penser à modifier le chemin dans votre code).

Gogle Head

Là, le "dude" suit le curseur du regard lorsqu'on le déplace. Les trajectoires de mouvement des yeux sont simplement des cercles (attention, trigonométrie !). J'ai laissé en commentaire quelques lignes qui facilitent l'ajustement des caractéristiques des trajectoires, si certains veulent s'amuser en changeant l'image de fond (de préférence au format PNG).

Gogle Head (pointeur en haut à droite de la fenêtre,
non-représenté)

Le code est disponible ici, et l'image de fond ici (penser à modifier le chemin dans votre code).

Liens :

Shoes
Mes autres articles sur Shoes
Divers tutos sur Shoes
La doc la plus "weird" au monde. Ou presque...
Les images de ces 2 scripts
Dans le même genre (en beaucoup mieux !) : Scatter Pack

ShoesFests

2008-07-10T20:56:00.006+02:00

Demain, Vendredi 11/07/2008 à partir de 8am GMT (soit 21H en France, Belgique, Suisse et Luxembourg ou 15H à Québec) pendant 24H, est organisée la ShoesFests sur le chan #shoes du réseau IRC Freenode (irc.freenode.net) ! Il s'agit de découvrir Shoes, le curieux toolkit de GUI de Why's The Lucky Stiff pour Ruby, d'écrire et partager de petits programmes avec Shoes en s'amusant, le tout en présence de Why's et d'autres rubyistes sympas. Cet event a pour but de tester et diffuser ce programme, tout en identifiant les problèmes de documentation et de clarté. Une seconde édition est prévue est prévue aux mêmes horaires le Vendredi 25 Juillet.

Après ça, on ne pourra plus dire que "Nobody Knows Shoes" !

Je vais essayer d'y passer demain soir, ça a l'air prometteur !

L'annonce chez :

Page de Shoes
Page de _Why's
Blog de _Why's
Liens vers des micro-tutos sur Shoes (chez Juixe, via _Why's)

Omniscientificoclasme : 1 - Les langages de programmation

2008-07-09T22:09:00.010+02:00

Je hais les omniscientifiques. Ceux qui croient tout savoir avec un aplomb digne de Chuck Norris : "Peu importe tes arguments, ma foi en mon propre savoir leur est supérieure.". Ceux qui gaspillent leur énergie à étaler leurs connaissances incomplètes. Ceux qui promeuvent leur culture et leur expériences seules, snobbant tout ce qui ne fait pas partie du cercle de leur "sélection" d'items de valeur. Ceux qui sont constamment blasés de tout (puisqu'ils l'ont déjà vu, lu ou fait, ou qu'ils connaissaient il y a déjà des lustres).

Les omniscientifiques ne sont pas omniscients : ils croient l'être.

Les omniscientifiques ne sont pas scientifiques : ils veulent l'être.

Il est temps de détruire cette engeance malfaisante. Et pour cela, il existe un moyen simple : détruire leur foi en leur savoir faussement complet. Comment ? En mettant en évidence les "trous", les "hiatus" et autres "manques" à leur connaissance, pour enfin faire renaître l'objectivité, l'humilité et la curiosité dans leur esprit biaisé.

Vous aussi, soutenez l'Omniscientificoclasme !

Allez, après la jolie intro, en avant Guingamp !

VOUS NE CONNAISSEZ PAS
TOUS LES LANGAGES DE PROGRAMMATION :

Vous ne connaissez pas GOTO++

GOTO++ est un langage exotique complètement loufoque. Son paradigme est "orienté goto" (vous avez bien lu !). Le GOTO++ doit son nom à l'instruction GOTOGOTO qui va à une étiquette "au pif" dans une liste donnée... Ses types de variables privilégiés sont les étiquettes, les chances, les pingouins, les troupeaux de pingouins, les bergers et les machines à pingouins. A noter qu'il y a aussi une tortue pour faire du dessin à la Logo.

Vous ne connaissez pas Scratch

Scratch est un langage de programmation développé par le MIT, spécifiquement pour les enfants. Basé sur Squeak (une implémentation dérivée de Smalltalk), il a principalement un but éducatif et est très visuel. Un point intéressant est que le langage est dans la langue maternelle de l'enfant (une vingtaine de langues européennes disponibles selon Wikipedia). Il est aussi assez orienté "multimédia" pour encourager le tout jeune hacker. Une guideline à noter (et approfondir peut-être) également est le principe du "Imagine-Programme-Partage" que l'on retrouve notamment dans Hackety Hack (dont on reparlera sans faute !).

Vous ne connaissez pas Factor

Factor est un langage dynamique basé sur la pile (dans la ligné de Forth donc). Il supporte également l'orientation objet, les macros à la LISP et les continuations. Mais ce n'est pas pour autant un langage exotique : toute plate-forme (sauf Solaris apparemment ?), bindings pour OpenGL, Cocoa, X11 ou Win32, client et serveur web, parser XML et autres, support de plusieurs BDD... Un "vrai" langage donc, encore moins connu que Io... avec un logo classe.

Dans notre lutte objective contre les omniscientifiques, ce n'est qu'une première bataille.

D'autres suivront !

NOTA : les images de cet articles appartiennent à leurs auteurs respectifs (Danil Kryvoruchko pour la première et probablement un propagandiste nord-coréen sans droit d'auteur pour la seconde).

Règles de codage, mes amours

2008-07-08T23:27:00.004+02:00

Il n'est pas rare d'avoir quelques règles de codage dictées lors du développement d'un programme dans une entreprise, ou dans un projet en général. En soi, c'est plutôt bien, ça rend souvent le code plus homogène, lisible ou maintenable. Certaines règles se justifient pour les besoins de performances, de documentation ou de fiabilité. Mais parfois...

Pas de ligne de plus de 131 caractères. Moral, mais pourquoi pas 132 ou 130 ?
Minimiser les boucles, mais maximiser leur portée. Hein ?
Pas d'identifieur (nom de classe, variable ou package) de plus de 31 caractères. Si ça parait évident, attendez de voir la suivante... (et celle d'après !)
Les noms des identifieurs doivent être clairs et représenter l'objet identifié. Par exemple, "Initialize_Space_Craft_With_One_Pilot" et non pas "Init_SC_with1_pilot". Hahahaha !!!
Interdiction d'utiliser use. RHAHahahaha... BANG!
Pas d'appel récursif. Boom.
Pas de condition IF sans ELSE. Peut se justifier par des raisons de fiabilité (le codeur a effectivement envisagé le cas contraire et écrit exlicitement null, avec commentaires dans le ELSE).
Dans les CASE-WHEN, interdiction d'utiliser when others. Moral pour la fiabilité (Ada95 plante si l'on omet un cas possible), parfois très pénible en pratique (heureusement que l'Ada admet les OR dans les CASE, parce qu'avec des litéraux de 15 à 20 entrées...).
Les variables doivent être déclarées dans l'ordre d'apparition dans le code. Dumbest rule ever.

J'en passe et des meilleures. L'important est surtout de mettre au point ces normes avant de commencer l'implémentation... Dommage pour certains, pas vrai ?

Mais quelles sont les règles de codage indispensables en réalité ? Celles qui apportent effectivement la lisibilité, la fiabilité et la maintenabilité ?

iRant

2008-07-07T23:00:00.011+02:00

Une fois n'est pas coutume, déversons un peu de bile contre un acteur important de l'informatique mondiale : Apple.

Cet article fait suite à l'achat par Lefty d'un câble alimentation pour son iBook, pour la modique somme de 75€ (français, nouveaux, TTC). Hahahahahurfff...

Apple fait de supers produits, certes. Jusqu'à il n'y a pas si longtemps, le matos était plutôt résistant, de bonne qualité, et surtout Apple était surtout un OS à toute épreuve : MacOS. Réputé sans virus, spyware et autres joyeusetés informatiques... Hélas...

Le fruit de la discorde : un logo trop cher.

Once upon a time, Macintosh c'était de drôles de PC avec des fenêtres, à l'époque ou Big Bilou jouait encore avec son caca sous DOS. Dans mon maigre souvenir, ces ordinateurs étaient très accueillants, simples et "ludiques". Et pourtant...

In the good old days...
-- Abraham Simpson

Le problème actuel d'Apple vient peut-être de cet aspect "ludique" présent dès le départ : jouant sur le côté design, "innovation technologique bien pensée" et se reposant beaucoup sur ses "fan-boys", la pomme commence à vraiment faire des erreurs.
L'iPod a révolutionné les lecteurs MP3 (entre autre avec l'AAC, touss touss...) mais la robustesse des différents modèles est assez relative. L'iPhone est sans doute un bon produit mais à quel prix ? Celui d'un cadre très supérieur qui n'a jamais les doigts gras (c'te chance !) et que ça ne dérange pas de devoir payer son abonnement très cher, chez un fournisseur unique (dans un premier temps). Quid du MacBook Air, horriblement cher pour ses perfs avec port Ethernet en option pour 29€ (???) et batterie non amovible ?

iButton, simplicity for Human Kind ($299,95)
-- Steve Jobs

Du côté logiciel, il y a aussi flottement... J'aime beaucoup iTunes, mais pas ses pµT4iN$ de processus (genre "Helper" !!!) qui tournent en permanence sans aucun raison. La suite bureautique iWork, à sa sortie, était assez ridicule avec tous ses formats uniquement accessibles en lecture et écriture par elle seule... Safari n'est pas un mauvais navigateur web, loin de là : il est basé sur WebKit (fork du moteur web de Konqueror (KHTML), logiciel génial de KDE sous Linux). Mais au niveau fonctionnalités c'est pas toujours pratique (pour les flux notamment), la sécurité est relative (pas mal de failles qui trainent trop longtemps ces derniers mois) , la sortie Windows ridicule dans ses premières versions et finalement assez peu personnalisable.

iHam: for real Apple fan-boyz mouf' (only $/kg 200)

A ce sujet, l'attitude d'Apple face au libre est assez ambivalente... Le projet Darwin semble assez poussif (même si pas inintéressant de base). Pareil pour ce qui est de l'ouverture des API, c'est pas franchement fabuleux... (et le format de sauvegarde disque, GRRR !!!)

Mais au niveau logiciel, ce qui est peut-être le plus gênant, c'est l'OS en lui même. MacOS X.5 ne me séduit pas vraiment. Tout comme Vista (la convergence entre les 2 OS étant de mise depuis le départ, malgré ce qu'on peut entendre là-dessus...), il me parait de plus en plus orienté vers l'"effet visuel", le widget et le "Oh-mon-Dieu-qu-il-est-beau-ce-doc-qui-brille-!!!". Bouffe ta RAM mec, fais toi plaisir... Pour ce qui est du fait que les Mac sont davantage touchés qu'avant par les virus, failles et autres, il faut reconnaître que le nombre croissant d'utilisateurs y est pour quelque chose, mais aussi l'utilisation bien plus intensive d'Internet qu'il y a quelques années seulement.

Tu retourneras poussière !
- Océdar

Bon allez, on en crâme un et on s'arrête là. C'est vrai que c'est cruel : Micro$oft, Sony ou Acer (et bien d'autres) méritent sans doute un châtiment bien pire pour leur pratiques et productions respectives. D'autant qu'au départ j'aime bien les Mac ! Mais au final, je ne risque pas de m'en payer un...

Nota : les images de cet article ne sont pas à moi, ni à Apple. Le vieil Apple II vient du blog de Giles Bowkett, l'iButton et l'iHam je ne sais plus, iSuck on s'en fout, et le "burnin' iBook" du site de Ratpoison. Enfin, le logo modifié est l'oeuvre du designer Mario Amaya.

Le Logiciel Libre expliqué à ma Maman (et à toute personne non portée sur l'informatique...)

2008-06-22T14:57:00.005+02:00

Le logiciel libre est une notion importante en informatique actuelle. Mais si n'importe quel geek, informaticien ou programmeur maîtrise ce concept, ce n'est pas le cas du grand public et particulièrement des personnes pour qui l'informatique n'est qu'un outil nécessaire, mais souvent un peu compliqué.

Le but de cet article est donc de tenter d'expliquer à ma mama n, et par extension à toute personne peu portée sur l'informatique ce qu'est un logiciel libre.
Dans ce cadre, il est très probable que je fasse des raccourcis, analogies ou approximations sur certaines notions ou concepts liés ; à l'attention des personnes pointilleuses sur ces points qui font parfois débat (ou troll), n'hésitez pas à utiliser les commentaires afin de mettre les choses au point, point (poin poin !).
Par ailleurs, seuls les geeks semblent maîtriser le web et avoir le temps de lire les pages présentées dans les liens (et d'autres choses, comme la navigation par onglets sous Firefox ^^) : donc, la plupart des liens pointent vers une simple image (Une image vaut mille mots.).

Qu'est-ce qu'un logiciel ?

Commençons par le commencement ! Word, Excel, Firefox, Outlook Express et iTunes sont des logiciels. C'est probablement ceux qu'utilisent le plus ma maman. Mais ce ne sont que quelques exemples. Window$, MacOS X et Linux sont également des logiciels : ce sont des systèmes d'exploitation (c'est à dire le logiciel qui gère l'interaction avec le matériel, écran, clavier, etc ainsi que la base pour les autres logiciels cités en premier.).
Mais il y a également des logiciels plus "discrets" pour l'utilisateur de base : les "drivers" (ou pilotes) qui font fonctionner du matériel (imprimante, webcam, etc...) sur un PC, les systèmes assurant les transmissions bancaires, les applications web (comme Gmail, ou ce blog), le manager de vol d'un avion, un code calcul scientifique, le système d'un téléphone portable, un guichet de retrait de monnaie ou encore la synchronisation des feux dans les grandes agglomérations.

Pour résumer, sur un ordinateur (au sens large), un logiciel est toute la partie non-matérielle. En anglais, on parle de "Harware" pour le matériel (partie "dure") et de "software" pour les logiciels (partie "légère" ou immatérielle).

Comment construit-on un logiciel ?

Sans trop rentrer dans la technique, quelques notions sont utiles pour la suite.
Tout logiciel est construit à partir d'un "code source" qu'écrit le programmeur, développeur ou codeur (ou ingénieur logiciel, mais celui-ci, il se la pète un peu je trouve ^^). De quoi s'agit-il ? Il s'agit d'un texte, écrit dans un langage spécialement conçu pour "communiquer avec l'ordinateur". Il existe de nombreux langages permettant d'écrire du code.
Le code source peut être défini comme un ensemble d'ordre et de définitions d'ordres que le codeur donne à la machine. Du coup, le code source d'un logiciel peut être comparé à une recette de cuisine à laquelle on ajoute une définition des gestes techniques (abricoter, brider, delayer, etc...).
Par exemple, ci-dessous voici à quoi pourrait ressembler le code permettant d'ouvrir une fenêtre contenant une horloge à l'heure :

Programme Fenetre-Horloge :
ouvrir fenetre
fenetre contient horloge(heure_actuelle)
toutes les 1 secondes : mettre l'heure à jour dans horloge
fin programme

Bien sûr il s'agit de pseudo-code : c'est à dire un langage de programmation que la machine ne comprendrait pas. Mais dans l'esprit, on n'est pas très loin de ce à quoi pourrait ressembler un vrai code source. La preuve, voici un vrai programme faisant ce que je viens de décrire, en Ruby (Ruby est donc un "vrai" langage de programmation) :

stack do
 background black
 para @time.strftime("%a"),
   span(@time.strftime(" %b %d, %Y "), :stroke => "#ccc"),
    strong(@time.strftime("%I:%M"), :stroke => white),
   @time.strftime(".%S"), :align => "center", :stroke => "#666"
end

(source : hackety.org par Why's the Lucky Stiff)

C'est déjà moins compréhensible, mais ça marche ^^ !

Qu'est-ce qu'un logiciel libre ?

Un logiciel libre est un logiciel dont la licence dite libre donne à chacun le droit d'utiliser, d'étudier, de modifier, de dupliquer, de donner et de vendre ledit logiciel.

Cette citation Wikipedia est selon moi une bonne définition de ce qu'est un logiciel libre.

Mini-Tux, une mascotte de Linux (libre !)

Contrairement à ce qu'on pourrait facilement penser, un logiciel libre n'est pas forcément un logiciel gratuit. C'est sa licence qui est libre, c'est à dire le texte "juridique" définissant les droits de l'utilisateur sur le logiciel. Même si la majorité des logiciels libres sont gratuits, il en existe quelques un payants, ou en version payante (on y reviendra).

En l'occurrence, l'utilisateur, quel qu'il soit, à le droit d'utiliser le logiciel comme bon lui semble.

Contrairement à la plupart des logiciels propriétaires (non-libres donc), l'utilisateur a également le droit de copier, donner, vendre ce logiciel dans certaines conditions. Il n'y a donc quasiment pas de piratage dans le monde du logiciel libre puisqu'on est libre de dupliquer et de distribuer ces logiciels. Je dis quasiment car les conditions ne sont parfois pas respectées : par exemple une condi tion de redistribution peut être de continuer à montrer le code source (ce que ne font pas toujours les entreprises).

Le droit de vente peut paraître surprenant : pourquoi vendre un logiciel qui peut ensuite être redistribué gratuitement ? En pratique, peu de logiciels libres sont payants. La plupart du temps, le code source du logiciel est gratuit, mais c'est le support associé qui est rémunéré. Par exemple, le logiciel de développement que j'utilise actuellement est libre, mais mon entreprise paye la société qui le distribue pour corriger rapidement les bugs que nous rencontrons, ou ajouter de petites fonctionnalités. Je peux par contre utiliser la version amateur, sans support, gratuitement, à la maison.

L'utilisateur a également le droit d'"étudier" le logiciel : en pratique, cela signifie qu'il a le droit d'accéder au code source du logiciel pour comprendre (ou essayer de comprendre) comment celui-ci fonctionne. On parle alors de logiciel "Open-source" puisque ses sources sont accessibles à tous ; "ouvertes". Bien entendu, ce droit est surtout destiné aux développeurs : ceux qui sont capables de lire le code source.
Hormis le côté éducatif, ce droit a un avantage direct pour un logiciel libre : les bugs et autres erreurs dans le code source sont visibles par tous et donc, le plus souvent, rapide ment détectés. Cela explique également pourquoi les logiciels libres les plus utilisés proposent des mises à jours régulières : les erreurs sont fréquemment corrigées et on en fait profiter les utilisateurs le plus rapidement possible.
Enfin, dans le domaine scientifique, il y a un autre intérêt direct : la vérification. Dans un code de calcul notamment, il devient possible de vérifier les formules et algorithmes qui ont été employés. En cela, le logiciel libre garde l'esprit scientifique (particulièrement mathématique / pas de brevets en maths) qui veut que le savoir soit accessible à tous.

Le logiciel libre en pratique

Beaucoup de logiciels libres sont soutenus par une "communauté". Ce terme, qui fait un peu penser à "secte", "hippy" ou "communisme", désigne simplement un groupe de personnes soutenant un logiciel libre. Il s'agit bien sur de programmeurs qui le développent, mais aussi de simples utilisateurs qui l'utilisent bien sûr, mais aussi qui le testent (et donc préviennent de certains bugs), le diffusent, écrivent de la documentation (aide, wiki, manuels, etc...), font sa publicité, aident les débutants ou même le soutiennent financièrement.

Ce côté communautaire fait souvent croire que le logiciel libre est uniquement l'affaire de quelques passionnés, et que les entreprises ne les emploient jamais. Cela est faux.

Pour le simple utilisateur, un logiciel libre a plusieurs avantages. Comme on l'a vu précédemment, il est souvent gratuit, facilement trouvable puisque librement distribuable et mis à jour régulièrement.
Ensuite, du fait de l'ouverture du code, les logiciels libres sont souvent personnalisables puisque n'importe qui peut proposer un module complémentaire (comme un aspect graphique ou un add-on sous Firefox).
Enfin, de par la compétition (pour ne pas dire guerre) entre les logiciels libres et les logiciels propriétaires, les communautés attachent beaucoup d'importance à aider les nouveaux arrivants, notamment sur les forums d'aide (en principe du moins...).

Un aspect important du libre en informatique réside dans les standards des formats, ce point étant vital pour les utilisateurs de base et probablement encore plus pour les entreprises. Un format, c'est les dernières lettres d'un fichier : par exemple .jpeg ou .gif pour une image, .mp3 ou .ogg pour une chanson, .doc ou .rtf pour un document texte ou encore .xls pour un classeur Excel.
Plus que trois lettres après un point, ces formats désignent la façon dont la machine écrie et lit ces documents : c'est une représentation de la donnée de départ en langage machine ; en règle générale, un être humain ne peut pas lire ces formats.
Le problème est qu'il existe des formats propriétaires. Une entreprise peut donc décider de déposer une licence propriétaire, ou un brevet sur un format qu'elle aurait "inventé". C'est le cas pour Microsoft avec le .doc et le .xls ou le .aac par Sony (entre autres). Alors, elle peut décider de "libérer" son utilisation ou non.
Dans tous les cas, ces formats posent problèment car d'une part, une entreprise peut décider d'abandonner un format (si Microsoft abandonne le .doc, comment ouvrir ses documents dans 10 ans ?) ou d'autre part de restreindre sa diffusion en faisant payer les producteurs d'autres logiciels l'employant. Ou encore de se réserver entièrement les droits sur un format : par exemple pour de l'audio pour écouter un tel format créé par Toshiba, vous devez acheter un lecteur Toshiba (simple exemple).

En général, les logiciels libres préfèrent créer ou/et employer des formats libres et standards assurant ainsi la compatibilité entre les différentes applications (par exemple un format de tableau pourrait être lisible par différents logiciels tableurs -comme Excel-) ainsi que la pérennité des documents.

Quelques exemples de logiciels libres (propriétaires) :

Firefox ; navigateur web (InternetExplorer, Safari, Opera...)
Thunderbird ; outil de messagerie (Outlook Express...)
Azureus, EMule ; peer-to-peer (?)
OpenOffice.org ; suite bureautique (Microsoft Office...)
Linux ; système d'exploitation (Windows, MacOS)
The Gimp ; dessin et traitement d'image (Paint, Photoshop...)
SciLab ; outil scientifique (MatLab, Maple...)

Références :

Logiciel (chez Wikipedia)
Logiciel Libre (chez Wikipedia)
Liste de logiciels libres par rubriques (Framasoft)

Alors Maman, tu as compris ?

Les commentaires sont ouverts !

Firefox 3 - D-Day !

2008-06-12T20:29:00.004+02:00

Je ne vais pas vous faire étalage des avantages de Firefox sur la concurrence dans le monde merveilleux des navigateurs web. Non. Mais je vous encourage vivement à participer au Download Day de Firefox 3.

Il s'agit d'essayer d'établir le record du plus grand nombre de téléchargements pour un logiciel en 24H. Amusant non ? Outre le fait que c'est un évènement marketing sympa, c'est l'occasion de découvrir, ou mettre à jour l'un des meilleurs navigateurs disponibles sous toute plate-forme.

Vous pouvez déjà effectuer une promesse de téléchargement sur la carte du monde (la France n'est d'ailleurs pas si mal placée ^^) ou patienter gentiment jusqu'à... Mardi 17 Juin (selon Silicon.fr, qui a réalisé il y quelques jours une interview de Tristan Nitot, Prez' de Mozilla Europe, sur la sortie du dernier panda rouge).

Bon téléchargement !

Ruby Duck-Safe interface

2008-06-07T00:14:00.005+02:00

Suite à un précédent article sur DiamondBack Ruby, j'ai un peu réfléchis à la question de la sécurisation de l'appel de fonctions/procédures/méthodes, au niveau des types dans un langage dynamique tel que Ruby (/Python,/Perl/Etc...).

Finalement, quel est le problème ? Quelque soit le paradigme, il se situe au niveau de la capacité d'une fonction/procédure/méthode à traiter ses arguments en fonction de leur type, classe ou comportement. Problème simple donc. (Les aspects plus bas niveau sont ici peu intéressants : on est actuellement capables de les éluder).

Tout est dans la notion d'interface : dans les langages statiques, une interface n'est pas seulement un moyen d'appeler un "service" (fonction/méthode/...) mais c'est également un "contrat" qui impose des conditions sur les informations passées à l'appel (le plus souvent sur leur type). Par exemple, la fonction acheter_une_baguette ne peut se contenter de prendre 0.45 en argument : il faut que 0.45 soit en €, "de type €".

Ruby est un langage dynamique comme tant d'autres. Mais de par sa conception, sa "philosophie", il fait le choix de se concentrer sur ce que fait un objet plutôt que sur ce qu'il est : c'est le Duck Typing. On peut facilement critiquer cette approche du typage pour plusieurs raisons. Cet article sur Otaku en expose plusieurs. Pour ma part, je me contenterais de dire qu'elle réside dangereusement sur la langue (quel rapport entre Balançoire.balancer et Coupable.balancer ?).

Mais les langages statiques ne sont pas nécessairement satisfaisants sur ce point non plus. Pour faire un parallèle avec les mathématiques, on peut considérer que :

f : R  -> R
    x |-> x + 2

avec R l'ensemble des réels, est une déclaration de type statique.

Pour autant, f reste valable de N dans N (naturels), de C dans C (complexes), etc... Le Duck Typing assure que f est valable du moment que x possède une méthode "+", ce qui évite de redéfinir f pour chaque espace où cette fonction est valable.

Mais est-ce suffisant ? Prenons :

f : x |-> 2 / x

Dans ce cas, on doit de plus assurer que x n'est pas nul. Si mathématiquement, cela s'exprime sur l'espace sur lequel est défini x, "informatiquement" on aura le plus souvent x entier ou flottant. Les contraintes sur un argument ne se limite donc pas à son type/classe, ni à son comportement (possède méthode "+"), mais aussi à d'autres paramètres, comme son état (ici sa valeur). De plus, s'il s'agit ici d'un exemple simple : il existe probablement d'autres exemples mettant en évidence l'influence du contexte d'appel.

Je vous propose ici un module (naïf) permettant d'exprimer assez simplement, lors de l'implémentation d'une méthode, les contraintes associées à ses arguments. Le but est d'assurer ces contraintes sans pour autant surcharger le code de structures conditionnelles avec gestion d'exceptions : on déclare simplement notre contrat.

(sources également disponibles **sans fuck1n' coupure** ICI)

module Safety

    # Negator for error message
    @@neg_converter = {:is_a?       => "is not a",
                       :respond_to? => "does not respond to",
                       :include?    => "does not include",
                       :each_element_is_a? => "contains element(s) that is(are) not"}

    # Ensure that constraints are respected
    def ensure_it cstr
        cstr.each do |arg, cstrs|
            value = cstrs[0] 
            cstrs[1...cstrs.size].each do |pair| 
                if not value.method(pair[0]).call(pair[1]) then
                    raise "Argument #{arg} (#{value.inspect}) \
                          #{@@neg_converter[pair[0].to_sym]} #{pair[1]}."
                end
            end
        end
    end
    
    private
    
    # A simple example of constraint method
    def each_element_is_a? klass
        assertion = true
        self.each do |elt|
            assertion = false if not elt.is_a? klass
        end
        assertion
    end
    
end

La méthode ensure_it checke les contraintes passées. Une contrainte est facilement exprimable par une méthode telle que each_element_is_a?.

Exemples :


require 'Safety'

class Fixnum
    include Safety
    def mult_by_plus num1, num2
        ensure_it({:num1 => [num1, [:is_a?, Fixnum]],
                   :num2 => [num2, [:respond_to?, :next]]})
        self*num1+num2
    end

end

a = 1
puts a.mult_by_plus(1,2)
puts a.mult_by_plus(1,1)
puts a.mult_by_plus(1,1.0) #=> Error raised

Et :


require 'Safety'

include Safety

def potamok tab
    ensure_it({:tab => [tab, [:respond_to?, :each],
                             [:each_element_is_a?, Fixnum]]})
    val = 0                         
    tab.each do |elt|
        val += elt**2
    end
    val
end

puts potamok [42,33,59]
puts potamok [1,2,3,6,59.3] #=> Error raised

Toute remarque est la bienvenue.

Google Reader pour Lefty

2008-05-30T23:59:00.003+02:00

Les flux RSS sont vraiment un moyen très puissant de se tenir au courant à moindre coût : c'est une application "assez" récente d'Internet, qui à mon avis est encore mal maîtrisée par l'internaute moyen (ce qui n'est pas le cas de Lefty, puisque celui-ci a un blog - waow ! -).

Présentation :

L'intérêt des flux RSS réside dans un principe très simple :

"Chercher une information qui vous intéresse sur le web est en soi une perte de temps : c'est l'information qui vous intéresse qui doit arriver à vous."

D'où ces flux qui vous tiennent au courant des dernières entrées du blog de votre pote qui joue de la gratte, des dernières nouvelles concernant les JO ou d'une réponse à votre message sur un forum de discussion.
La question est comment ? Comment profiter de ces outils le plus simplement et naturellement possible ?

Il existe grosso-modo 3 méthodes :

Via son navigateur web
Via un agrégateur de flux offline et/ou son logiciel de messagerie
Via un agrégateur de flux online

La plupart des navigateurs web modernes intègrent des outils de lecture de flux RSS/ATOM. Mais dans l'ensemble je les trouve reltivement peu pratiques. Le modèle de Safari est assez peu intuitif, avec un rendu assez médiocre. Opera est un peu mieux sur ce point, mais j'accroche pas. Firefox (v2, j'attends la suite...) par contre, propose les marque-pages dynamiques qui peuvent être intéressants : ceux-ci se présentent comme des favoris classiques qui se déroulent pour révéler les dernières entrées du flux. C'est surtout pratique pour les flux souvent mis à jour (tumblelog, blogger hyperactif ou site d'informations), mais là encore, il faut faire l'effort de cliquer dessus pour être tenu au courant (monde de feignants...).

Les agrégateurs de flux, eux, se présentent davantage comme des logiciels de messagerie, recevant les entrées comme des messages. D'ailleurs, différents logiciels de messagerie proposent cette fonctionnalité, Mozilla ThunderBird notamment.

Mais il existe une méthode qui paraît plus "logique" : les agrégateurs de flux online comme Google Reader, NetVibes (qui est en fait un peu plus qu'un simple agrégateur : plus proche d'iGoogle peut-être...) ou BlogLines (et bien d'autres...).

Google Reader :

Je vais m'intéresser maintenant plus particulièrement à Google Reader. (Non, je n'ai pas d'action chez Google : je ne leur fais pas de pub... juste de la propagande. On en reparlera...)

L'intérêt, à mon sens, de Google Reader, c'est qu'il se présente quasiment comme Gmail : si on utilise cette messagerie, on ne sera pas dépaysé.
Pour ajouter des abonnements, rien de plus simple : on peut entrer l'URL du flux désiré (via "ajouter un abonnement"), ou importer une liste de flux (fichier au format OPML) dans "Gestion des abonnement/Importer" ou encore lancer une recherche et attendre les propositions du moteur. Si en plus on possède un navigateur profondément bon (comme, je sais pas moi... Firefox ?), celui-ci vous propose de l'y ajouter lorsque vous cliquez l'icône d'abonnement sur un site.

En dehors des fonctionnalités de base, comme tagger ses articles, assurer un suivi, ajout à iGoogle et quelques stats, Google Reader permet également de "partager" des items. C'est à dire que suite à la lecture d'un très bon article sur l'un de vos flux, vous pouvez cliquer sur "Partager" pour l'ajouter à votre page de partage. Cette page web est "publique" et est donc accessible à quiconque en connait l'adresse : à fournir à vos amis par exemple.

Mais allons un peu plus loin. Il existe évidemment un widget pour ajouter vos derniers coups de cœur à votre site ou à votre blog (painless, surtout chez Blogger). Du coup, on obtient quasiment un "Tumblelog" (blog avec messages très courts, le plus souvent un simple lien vers une page intéressante).
Attention, maintenant grosse manip' bien technique : dans "Paramètres", passer la langue en Anglais et là "KABOOM"* : vous pouvez à présent ajouter des notes qui seront partagées par défaut (décocher la case "Share" sinon) et la possibilité de changer l'apparence de votre page de partage (d'où les petits ninjas sur la mienne**). Du coup, on a effectivement un Tumblelog à pas cher...

Je suis sûr que ça va intéresser Lefty...

* : Si vous ne parvenez pas à effectuer cette manipulation, merci de contacter notre équipe d'assistance au 080808, 44€55/s...
** : Dans la colonne de droite, juste en dessous de la pub sur laquelle vous ne cliquez jamais bande de rats !
*** : Les images de cet article appartiennent à leurs propriétaires respectifs. Pas à moi donc...

Typage statique pour Ruby

2008-05-21T23:47:00.005+02:00

Via cet article sur Segment7, voici le lien vers une publication sur le développement de DRuby (DiamondBack Ruby) [:en, :pdf] : un outil (codé en OCaml) visant à autoriser le typage statique en Ruby. Le code source de cette application devrait être publié dans les mois à venir.

J'ai un avis assez mitigé sur ce genre de projet : d'un côté, j'apprécie la possibilité de choisir (cf. article précédent sur le typage en Groovy), et je reconnais tout à fait beaucoup des avantages du typage statique. Parmi eux, une certaine fiabilité et la détection précoce d'erreurs de développement.
Mais en Ruby (Perl, Python, etc...) ? L'un des avantages de ces langages dynamiques n'est-il pas d'"éluder" au maximum les contraintes de type pour un développement plus rapide et libre ? En Ruby en tout cas, la "philosophie" veut que l'on s'intéresse davantage au comportement d'un objet (no primitive type here !) qu'à sa classe (principe du "Duck Typing"). On croise donc plus souvent des foo.respond_to? :a_method que des foo.is_a? A_Class.

Il est cependant intéressant de se poser la question suivante (et pas seulement en Ruby !) :

Comment et/ou avec quelles techniques, assurer la fiabilité d'un programme dans un langage dynamique ?

Je vais essayer de bientôt placer quelques petits exemples de code sur ce sujet.

Ruby : Création dynamique de méthodes

2008-05-15T22:39:00.009+02:00

Ola Bini vient de publier un article très bien fait sur les différentes façons disponibles en Ruby pour la création dynamique de méthodes.

Pour cela, il envisage trois voies : le def classique, la méthode define_method ou l'une de ces deux dans un eval. Plusieurs paramètres importants dans le choix de la méthode utilisée :

Performances (à ce titre, voir cet article déconseillant l'usage de la métaprogrammation...)
Portée lexicale
Fuites mémoires

De façon assez amusante, il recommande pour des questions de vitesse, surtout, d'utiliser en priorité le def classique. Juste pour l'exemple, voici le code d'une définition par def, dans un eval :

class Foo
end

bar = Foo.new
method_name = :something

eval "def bar.#{method_name}; puts 'Hi !'; end"

bar.method(method_name).call
#=> Hi !

MetaTricks : Un petit DSL

2008-04-27T21:43:00.005+02:00

Depuis quelques temps, j'avais envie de tester s'il était facile ou non d'implémenter un petit DSL (ou Domain Specific Language) en Ruby. Il se trouve que plutôt, oui. Le code collé chez Pastie :

Code DSL

Le langage que je vous propose est loin d'être Turing-complet : ce n'est pas le but. Dans sa forme actuelle, il gère les transferts entre les "comptes" de plusieurs personnes grâce à une syntaxe en anglais. Trois verbes disponibles : donner, recevoir et avoir. Les phrases sont formées de la façon suivante :

"Sujet" "Verbe" "Somme" $ [complément]

Avec pour complément facultatif :

"Cibleur" "Second compte"

Il est possible de commenter une ligne en la commençant par "--" (comme en Ada !). Un "cibleur" ('to' ou 'from') désigne un autre compte. Attention, pour des raisons de blocage mental de ma part à l'approche d'une Regexp, la somme d'argent doit être un entier, et non un flottant. Pas de centimes pour les vrais. Ah, oui, et pas de point à la fin des phrases. Il parait que ça sert à rien(.)

Un exemple ?

-- Marie is cool:
Marie gives 5 $ to Peter
Marie has 10 $
Marie receives 15 $ from Peter
Peter gives 10 $ to Simon because he previously borrowed him...
-- Marion is Marie's dark-twin...
Sobe receives 1 $ from Marion
-- But Sobe's a gangsta who gat connectionz so:
Sobe receives 100000 $ like this !

est valable, et donnera :

--------------------
-= Report =-
--------------------
Number of accounts: 5
Marie owns 25.0 $.
Peter lost 20.0 $.
Simon earned 10.0 $.
Sobe earned 100001.0 $.
Marion lost 1.0 $.

C'est loin d'être parfait, mais le corps de l'interprète fait à peine 200 lignes. Je suis juste un peu déçu de ne pas avoir davantage employé les outils de la métaprogrammation : je passe sans doute trop par de l'analyse de chaîne de caractère, opération en soit risquée.

Tout commentaire ou critique vivement apprécié(e).

Ruby : Sécuriser la redéfinition de méthode

2008-04-23T22:38:00.004+02:00

Etant un peu angoissé de nature, il y a un truc qui me tracasse en Ruby depuis quelques temps : l'absence de warning à la redéfinition de méthodes existantes. Un exemple ?


class Object
    def self.new
        puts "Oh dude !"
    end
end

a = Array.new 46
#=> **Judgement Day**

Ceci devrait bien vous convaincre de l'utilité d'avertir le programmeur durant le développement. Rappelons aussi que Object.methods dénombre 77 méthodes pour cette racine de tout objet en Ruby...

Du coup, voilà un petit trick qui permet de sécuriser ce point, grâce à la méthode de classe method_added :


class Object
    def self.method_added sym
        if self.methods.include? sym.to_s then
            print "WARNING: method #{sym}" + \\
            "of class #{self} redefined\n"
        end
    end
end

class Integer
    def clone
        puts "I'm your dark twin !"
    end
end
#=> WARNING: method clone of class Integer redefined

MetaTricks : Ciseaux pour enfants

2008-04-07T22:54:00.003+02:00

Les 28 et 29 Mars derniers a eu lieu la MountainWest RubyConf 2008, une série de présentations sur la programmation en Ruby. Il y a beaucoup de conférences de Rubyistes et de Railistes à travers le monde (certains en sont d'ailleurs agacés...), mais celle-ci me semble avoir été particulièrement riche, avec des sujets très intéressants : DSL, cœur du langage, écosystème général, et... métaprogrammation.

Je n'ai pas la chance d'avoir été sur place mais, miracle du web oblige, les vidéos des différentes présentations sont disponibles (en bonne voire très bonne qualité, avec les slides en direct) à cette page. Merci Confreaks !

La présentation de Giles Bowkett est particulièrement réussie :

Code Generation : The Safe Scissors of Metaprogramming

Giles Bowkett, dont j'ai régulièrement parlé ici (générateur de MIDI en Ruby, métaprogrammation...), y parle bien sûr de métaprog' et de génération "automatique" de code, le premier étant un outil pour le second.
Il est assez difficile de résumer ce type de présentation en quelques mots, et je vais donc lancer ça en vrac :

Archimède et mathématiques par les cercles en Grèce.
Les Rubyistes pratiquent des "langages exotiques" : Scala, Erlang, Haskell, Lisp, Io, Scheme, Smalltalk... mais ne parle pas Grec !
De Pi "The Circle" à Lambda "The Ultimate" en LISP.
3 piliers improbables : Rubinius, Nodebox et "code == data".
Ruby2ruby
"Monkeypatch Monkeypatching is Metamonkeypatching"
Avantages économiques de la génération de code.
Pub pour "Code Generation in Action"...
De Java à Rails en passant par LISP (et Perl ! (et Smalltalk !)).
"Skilled programmers can write better programmers than they can hire."

Avec de l'humour absurde au milieu, du code en live et de la bonne humeur... Très agréable à regarder. Les deux seuls reproches que je pourrais faire sont d'une part qu'il passe un peu trop vite (à mon goût) de l'"historique" à la pratique, et d'autre part que les domaines d'applications proposés en exemple ne me paraissent pas assez ambitieux, surtout venant de lui ; G. Bowkett n'étant pas le dernier des n00bs : parmi ses petites réalisations persos on trouve autre chose que des applis en Rails : API pour le robot Lego, générateur de MIDI, programmation graphique, diverses gems... visitez son site ! (ou retrouvez les autres présentations ici.)

Une classe pour une fonction

2008-04-02T22:03:00.007+02:00

Une petite idée comme ça : plutôt que d'appeler directement une fonction, comme ici (loi des gaz parfaits) :

def compute_p v, n, t
    r = 8.314
    p = (n*r*t)/v
    return p
end
puts "p = #{compute_p(1.0, 10.0, 273.5)}"

Pourquoi ne pas créer une classe, représentant cette fonction ? En effet, on peut alors définir un certain nombre d'options à l'exécution "internes" à notre fonction (ici, j'ai mis des exemples simples : print pour un affichage console, et clock pour retarder l'exécution d'un temps donné). On pourrait aussi sécuriser les arguments (non fait ici...) par rapport à des contraintes internes à la classe (ex : température > 0, autre ?) ou décider de remplacer certains arguments sous certaines conditions, éventuellement externes. Et bien d'autres choses, pour des problématiques concurrentielles... Des idées ?

class Compute_p_class
    
    # Initializing the arguments as attributes
    def initialize args 
        @v = args[:v]
        @n = args[:n]
        @t = args[:t]
        @@r = 8.314
        @opt = []
        @opt_args = {}
    end

    
    # To add an option at execution
    def add_option option, argopt = nil
        @opt.push option
        @opt_args[option] = argopt
    end    
    
    # Wait for @opt_args[:clock] s before executing    
    def option_clock
        t_beg = Time.now
        t = t_beg
        if @opt.include? :clock then
            while t < t_beg + @opt_args[:clock]
                t = Time.now
            end
        end
    end
    
    # Verbose-like
    def option_print
        if @opt.include? :print then
            puts "Executing function Compute_p"
            puts "with arguments"
            puts "v = #{@v}"
            puts "n = #{@n}"
            puts "t = #{@t}"
        end
    end   
 
    # Execution after options
    def execute
        # Options management
        option_print        
        option_clock
        # Function core
        p = (@n*@@r*@t)/@v
        return p
    end    
end

values = {:v => 1.0, :n => 10.0, :t => 273.5}
calcul = Compute_p_class.new values
calcul.add_option :clock, 5.0
calcul.add_option :print

puts "p = #{calcul.execute}"

Jeu de Nim en Fortran

2008-03-30T01:41:00.005+01:00

Vous connaissez peut-être le jeu de Nim sous le nom de "jeu des allumettes"... Version Frotran 90 "sale" ("Goto statement considered harmfull", non respect des normes actuelles...) en mode console. Au passage, je teste l'outil de conversion html de (g)Vim (f*ck it ça passe pas...)... Got a problem homie ? Just tell me (give my money and buy my medecine...). Version collée chez Pastie pour plus de lisibilité (lignes trop longues, etc...) : goto ICI.

Ze code :
(compilé avec GFortran (fortran 90) sous Windows)


Program Jeu_de_Nim
 IMPLICIT NONE
 
 integer :: nbre_allum, ordre, choix, scorePC, scoreHumain, nb_parties, i, aleas
 logical :: PC_first, tournoi
 
 
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 ! BIENVENUE
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

 print*, "!!!!!!!!!!!!!!!"
 print*, "JEU DE NIM v2.0"
 print*, "!!!!!!!!!!!!!!!"
 print*, "Bienvenue dans ce petit jeu de Nim."

 print*, "A chaque tour, le joueur ou le PC doivent prendre 1, 2 ou 3 allumettes."
 print*, "Celui qui prend la derniere allumette a perdu. Bonne chance."
 print*, "      "
 
 scorePC = 0
 scoreHumain = 0
 tournoi = .FALSE.
 
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 ! MENU

 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
111 print*, "Entrez votre choix :"
 print*, "[0] : Nouvelle Partie"
 print*, "[1] : Nouveau Tournoi"
 print*, "[2] : Afficher Scores"

 print*, "[3] : Reinitialiser les Scores"
 print*, "[4] : Quitter"
 read*, choix
 
 SELECT CASE (choix)
  CASE (0)
   GOTO 222
  CASE (1)
   tournoi = .TRUE.
   scorePC = 0
   scoreHumain = 0
   11 print*, "Tournoi en combien de parties ?"

   read*, nb_parties
   if (nb_parties < 1) then
    print*, "Tssss... Trop drole..."
    GOTO 11
   end if
   
   aleas = 2*rand()
   
   PC_first = .TRUE.
   IF (aleas == 1) PC_first = .FALSE.
   i = 0
   10 i = i+1
   print*, "PARTIE numero : ", i
   call Afficher_scores(scorePC, scoreHumain)
   IF (i > nb_parties) then
    call Afficher_scores(scorePC, scoreHumain)
    if (scorePC > scoreHumain) print*, "LE PC GAGNE LE TOURNOI !!!"

    if (scorePC == scoreHumain) print*, "EGALITE !!! INCROYABLE !!!"
    if (scorePC < scoreHumain) print*, "VOUS GAGNEZ LE TOURNOI !!! BRAVO !!!"
    GOTO 111
   END IF

   
   nbre_allum = 50*rand() + 1
   PC_first = .NOT.PC_first
   GOTO 223
   
  CASE (2)
   call Afficher_scores(scorePC, scoreHumain)
   GOTO 111
   
  CASE (3)
   scorePC = 0
   scoreHumain = 0
   GOTO 111
   
  CASE (4)
   GOTO 666
   
  CASE DEFAULT

   print*, "Mauvais choooooooooooix......"
   GOTO 111
   
 END SELECT
 
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 ! PARTIE
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

222 print*, "Combien d'allumettes pour la partie ? (0 pour un nombre au hasard)"
 read*, nbre_allum
 if (nbre_allum == 0) nbre_allum = 50*rand()+1
 if (nbre_allum < 0) then
  print*, "Hummmmmm... Pas beaucoup ca..."
  GOTO 222
 end if
 print*, "Qui joue en premier ?"

 print*, "[1] : PC"
 print*, "[2] : Humain"
 print*, "[3] : Au hasard"
 read*, ordre
 
 SELECT CASE (ordre)
  CASE (1)
   PC_first = .TRUE.
   print*, "Le PC commence."

  CASE (2)
   PC_first = .FALSE.
   print*, "L'humain commence."
  CASE (3)
   aleas = 2*rand()
   PC_first = .TRUE.
   IF (aleas > 1) PC_first = .FALSE.
  CASE DEFAULT

   PC_first = .TRUE.
   print*, "Apprends a taper cono !"
   print*, "Du coup le PC commence..."
 END SELECT
 
223 IF (PC_first) THEN

  do while (nbre_allum > 0)
   call Tour_de_jeu_PC(nbre_allum,scoreHumain)
   IF (nbre_allum > 0) call Tour_de_jeu_Humain(nbre_allum,scorePC)
  end do
 ELSE
  do while (nbre_allum > 0)
   call Tour_de_jeu_Humain(nbre_allum,scorePC)
   IF (nbre_allum > 0) call Tour_de_jeu_PC(nbre_allum,scoreHumain)
  end do
 END IF
 
 IF (tournoi) GOTO 10
 
 GOTO 111
 
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

 ! EXIT
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
666 print*, "MERCI, A BIENTOT !"

End Program Jeu_de_Nim

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! AFFICHAGE DES SCORES
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Subroutine Afficher_scores(scPC, scHuman)
 integer, intent(in) :: scPC, scHuman
 
 print*, "!!!!! SCORE !!!!!"

 print*, "PC     : ", scPC 
 print*, "Humain : ", scHuman
 
End Subroutine Afficher_scores

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! TOUR PC
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Subroutine Tour_de_jeu_PC(nb_al, scHuman)
 integer, intent(inout) :: nb_al, scHuman
 integer :: reste, prise
 
 print*, "Il y a ", nb_al, "allumettes."

 reste = MOD(nb_al,4)
 
 if (nb_al == 1) then
  prise = 1
 else
  SELECT CASE (reste)
   CASE (1)
    prise = 3*rand()+1
   CASE (2)
    prise = 1
   CASE (3)
    prise = 2
   CASE (0)
    prise = 3
   CASE DEFAULT

    print*, "Erreur : module inconsistant"
    print*, "Module = ", reste
    STOP
  END SELECT
 end if
 
 nb_al = nb_al - prise
 print*, "Le PC prend ", prise, " allumettes."

 print*, "Il reste : ", nb_al, "allumettes."
 
 if (nb_al == 0) then
  print*, "VOUS AVEZ GAGNE !!!!! FELICITATIONS !!!!"
  scHuman = scHuman + 1
 end if

End Subroutine Tour_de_jeu_PC


!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! TOUR HUMAIN
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Subroutine Tour_de_jeu_Humain(nb_al, scPC)
 integer, intent(inout) :: nb_al, scPC
 integer :: prise
 
 print*, "Il y a ", nb_al, "allumettes."

 print*, "Combien souhaitez vous en prendre ? (1, 2 ou 3)"
999 read*, prise
 
 if ((prise > 3).OR.(prise < 1).OR.(prise > nb_al)) then
  print*, "Nombre saisi incorrect : veuillez recommencer."
  GOTO 999
 end if

 nb_al = nb_al - prise
 print*, "Vous avez pris ", prise, " allumettes."

 print*, "Il reste : ", nb_al, "allumettes."
 
 if (nb_al == 0) then
  print*, "VOUS AVEZ PERDU !!!!!"
  scPC = scPC + 1
 end if
 
End Subroutine Tour_de_jeu_Humain