Affichage des articles dont le libellé est programmation. Afficher tous les articles
Affichage des articles dont le libellé est programmation. Afficher tous les articles

samedi 17 octobre 2009

Io Language Libraries and Tools

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)


Last update: 17th October 2009

vendredi 10 juillet 2009

Fin de projet SCADE

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

mardi 23 juin 2009

Les promesses de la programmation fonctionnelle

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 !

mercredi 1 avril 2009

Algorithme naïf de cryptage d'entrée

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.

lundi 16 mars 2009

Animal Quiz en Ruby

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) :


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.

jeudi 19 février 2009

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

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...).

lundi 16 février 2009

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

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=~

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).

dimanche 15 février 2009

Langages en construction

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.

mardi 23 décembre 2008

Notations...

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.

dimanche 14 décembre 2008

3 petits Reddits

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.

vendredi 31 octobre 2008

Pourquoi utiliser Ruby ?

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 ^^




mardi 23 septembre 2008

Une tortue avec Processing

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 :

Dans le même genre...

Amusez-vous bien !

dimanche 14 septembre 2008

Ruby : Renommer un ensemble de fichiers

Logo Ruby 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

mardi 19 août 2008

Medicolor : le code

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).


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 !

mercredi 6 août 2008

Classe Struct en Ruby

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 :

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

mardi 5 août 2008

Medicolor : 2