27 Octobre 2011
Aventure romaine en Logo
Juste pour le plaisir, je me suis lancé ce soir dans un petit développement avec ACSLogo. Cet environnement de développement est une adaptation performante du langage Logo qui présente l’intéressante caractéristique d’être parfaitement intégrée dans Mac OS X.
Le projet est très classique : il s’agit d’implémenter l’algorithme du chiffre de César basé sur le décalage des caractères pour crypter un message. Pour rendre un document illisible, on décale d’une lettre chaque lettre du message (le A devient B, le B devient C, … , le Z devient A).
Pour réaliser cet algorithme, nous allons définir différents mots dans le dictionnaire de Logo. Par habitude, j’ai choisi d’utiliser le vocabulaire anglais mais vous pouvez bien sur utiliser également les instructions françaises.
La procédure cesar est le point d’entrée. Elle reçoit en paramètre une liste de mots qui seront ensuite cryptés.
Define “cesar [ [ liste.de.mots ] [ local "position local "resultat make "position 1 make "resultat [ ] repeat count :liste.de.mots [ make "resultat lastPut (crypte.mot item :position :liste.de.mots) :resultat make "position (sum :position 1) ] show :resultat ] ]
Le corps de cette procédure consiste à parcourir chaque mot de la liste et à les traiter par une procédure nommé crypte.mot. Les valeurs retournées par cette procédures sont ajoutées à une liste nommée resultat qui au terme de la boucle, est affichée à l’écran.
Define “crypte.mot [ [ mot ] [ local "position local "lettre local "mot.crypte make "position 1 make "mot.crypte " repeat count :mot [ make "mot.crypte lastPut (change.lettre (item :position :mot)) :mot.crypte make "position (sum :position 1) ] output :mot.crypte ] ]
Cette procédure est basé sur le même modèle que la procédure Cesar mais il ne s’agit plus ici de traiter chaque mot mais chaque caractère d’un mot. Le résultat, stocké dans la variable locale mot.crypte, est retourné à la procédure appelante.
Define “change.lettre [ [ lettre ] [ local "code.ascii make "code.ascii (ascii :lettre) if (or (and :code.ascii > 64 :code.ascii < 91) (and :code.ascii > 96 :code.ascii < 123)) [ make "code.ascii (sum :code.ascii 1) if (or (:code.ascii = 91) (:code.ascii = 123)) [ make "code.ascii (difference :code.ascii 26) ] [ ] make "lettre char :code.ascii ] [ ] output :lettre ] ]
La procédure change.lettre est le coeur de notre code. C’est ici que chaque caractère est décalé dans l’alphabet. Pour cela, le caractère est converti en valeur numérique par la recherche de son code ASCII. La procédure s’assure ensuite que le caractère est bien une lettre. Pour cela, son code ASCII doit être compris entre 65 et 90 pour les majuscules et entre 97 et 122 pour les minuscules. Dans l’affirmative, la code ASCII du caractère est incrémenté de 1. Si le nombre obtenu est hors des limites, la valeur 26 est soustraite (ainsi un “Z” devient ainsi un “A” et un “z” devient un “a”).
Pour vérifier le bon fonctionnement de notre code, saisissons l’instruction suivante dans l’écran interactif de ACSLogo :
cesar [ Logo, c’est cool ]
Pour exécuter cette ligne, il vous faut presser simultanément les touches Cmd et Entrée. Le résultat obtenu est le suivant: [ Mphp, d’ftu dppm]
B cjfoupu qpvs ef opvwfmmft bwfouvsft ;-)
6 Octobre 2011
Pharo - Mise en page des composants graphiques
Aujourd’hui, nous allons nous intéresser à l’agencement des composants graphiques dans une fenêtre. Ceux ci peuvent être positionnés selon deux stratégies de base, imbricables l’une dans l’autre :
- Un affichage en colonne où chaque composant se place en dessous de celui qui le précède,
- Un affichage en ligne où chaque composant se place à la droite de celui qui le précède.
Cette gestion de l’affichage, qui ne tient pas compte des coordonnées, permet de gérer avec souplesse le positionnement des composants graphiques et de réaliser rapidement des interfaces indépendantes de la résolution de l’écran.
Reprenez l’exemple précédent et modifiez le légèrement pour dessiner un L composé de boutons. Tout d’abord, créez une méthode #addButton qui définit un bouton et son comportement.
bouton>>#addButton ^self builder newButtonFor: self action: #helloButtonClick label: 'Hello' help: 'Affiche un message hello'.
Modifiez maintenant la méthode d’instance #open pour positionner trois boutons dans une colonne et ensuite, trois boutons sur une même ligne.
open
| content |
content := self builder newColumn: {
self addButton.
self addButton.
self addButton.
self builder newRow: {
self addButton.
self addButton.
self addButton.
} }.
(content openInWindowLabeled: 'Mise en page') extent: 400@200.
Pour découvrir le résultat, exécutez dans un Workspace la commande “Bouton open”. Le résultat sera le suivant :
24 Août 2011
Une date au format français
Si comme moi, vous avez besoin de formater une date dans le format français dd/mm/yyyy avec Pharo, il vous suffit d’ajouter une méthode #ddmmyyyy à l’objet Date (catégorie Kernel-Chronology).
Date>>#ddmmyyyy "Answer the receiver rendered in standard French format dd/mm/yyyy." ^ self printFormat: #(1 2 3 $/ 1 1)
Ce qui donne dans un Workspace:
Date new mmddyyyy. '1/1/1901' Date today ddmmyyyy '24/8/2011'
Simple et pratique ;-)
Clic, clic avec Pharo
ça fait un petit moment que je me promet de partir à la découverte de la construction d’interfaces graphiques avec Pharo. Commençons aujourd’hui avec un exemple simple: un bouton cliquable.
Pour cela, nous devons créer une catégorie “Bouton” contenant une classe nommé également “Bouton”. Dans cet classe, nous créons la méthode de classe #open :
Bouton class>>#open ^ self new open.
Cette méthode instancie notre objet bouton et appelle la méthode d’instance #open qu’il contient.
Passons maintenant du coté instance pour définir les propriétés et méthodes nécessaires. Nous devons tout d’abord ajouter une variable d’instance nommée “builder” qui nous permettra de construire les éléments de notre interface graphique. Deux accesseurs permettent de lire ou d’écrire dans cette variable d’instance. Ce constructeur, qui retourne un objet de la classe ComposableMorph, est initialisé par la méthode “initialize”.
Bouton>>#builder ^ builder Bouton>>#builder: anObject builder := anObject Bouton>>#initialize self builder: UITheme builder.
Nous pouvons maintenant ajouter la méthode d’instance #open qui construit l’interface graphique dans la variable locale content avant de l’afficher dans une fenêtre dont le titre est “Bouton” et dont les dimensions sont de 200 pixels de largeur sur 50 pixels de hauteur. Le bouton, définit par la méthode #newButtonFor, occupe l’intégralité de la fenêtre car il est le seul élément placé à l’intérieur.
Bouton>>#open | content | content := self builder newButtonFor: self action: #helloButtonClick label: 'Hello' help: 'Affiche un message hello'. (content openInWindowLabeled: 'Bouton') extent: 200@50.
Etudions plus en détail la définition d’un bouton. Son intitulé est renseigné à l’aide du paramètre “label”. Une bulle d’aide, qui apparaîtra lors de son survol, est définie avec le paramètre “help”. Avec le paramètre “action”, nous pouvons spécifier le nom d’une méthode qui sera appelée lorsqu’un utilisateur cliquera sur le bouton. Dans cet exemple, c’est la méthode #helloButtonClick qui est exécutée à chaque utilisation du bouton.
Button>>#helloButtonClick Transcript show: 'hello'; cr.
Cette méthode affiche simplement un message dans la console Transcript de Pharo.
Pour tester cet exemple, il nous suffit d’ouvrir une fenêtre Transcript, de saisir et d’exécuter la ligne suivante dans le Workspace: “Bouton open”. Nous obtenons alors une fenêtre dont les différentes fonctionnalités sont implémentées. Il est ainsi possible de réduire, de maximiser, de fermer ou de modifier les dimensions de la fenêtre. L’affichage du bouton contenu est automatiquement adapté.
C’est tout pour aujourd’hui. Dans un prochain article, nous nous intéresserons à la mise en page de nos composants graphique ;-)
9 Juin 2011
Mon eeePC est formidable
J’adore mon eeePC 701. Avant même sa sortie, j’avais trainé des semaines sur l’excellent site blogeee pour suivre les informations au sujet de sa sortie en France. Depuis cette date, je me sépare rarement de lui et il constitue un outil quasi parfait pour prendre des notes, regarder un DIVX ou programmer quelques lignes de code.
Progressivement, la configuration de la machine a évoluée. Une carte SD de 4 Go pour stocker, une barrette de 1Go de ram, une clé USB Bluetooth et une batterie 7200 mAh ont amélioré les performances de la petite machine noire. Côté système, La distribution Xandros d’origine a été remplacé par une Ubuntu 10.04 LTS et là, les problèmes ont commencé. L’autonomie de mon ordinateur a été sérieusement réduite et pire, les indications fournies par la jauge de la batterie sont devenues totalement aléatoires.
Par manque de temps, j’avais laissé tomber ce problème et puis hier soir, je me suis décidé à prendre la situation en mains. Après quelques essais, je suis parvenu à pratiquement doubler l’autonomie de mon eeePC en la faisant passer de 1 heure 30 à 3 heures avec la modeste batterie 3 cellules d’origine (5200 mAh).
ACPI, tu forceras
En tant qu’administrateur (root), j’ai tout d’abord éditer le fichier /etc/default/grub et modifier le paramètre GRUB_CMDLINE_LINUX_DEFAULT.
GRUB_CMDLINE_LINUX_DEFAULT="quiet splash acpi_osi=Linux acpi_backlight=vendor"
Il faut ensuite valider la modification en utilisant la commande grub-update et redémarrer la machine.
L’énergie, tu configureras
Une fois l’ACPI activée, il est ensuite possible de configurer la gestion d’énergie du bureau Gnome. Il faut cliquer sur la jauge et définir le comportement de Linux lorsque la machine fonctionne sur batterie. J’ai réglé un temps assez court pour l’extinction de l’écran et activé également l’arrêt du disque dur par le système (ce qui logiquement doit cesser d’alimenter le disque SSD).
La jauge, tu régleras
Sous Ubuntu 10.04, la jauge affiche l’énergie restante de manière incorrecte. Cela est dû à une incompréhension entre le système et le contrôleur électronique de la batterie. Il faut utiliser la commande suivante :
gconftool-2 --set /apps/gnome-power-manager/notify/low_capacity --type bool 0
Les journaux, sur le disque, tu éviteras
Autre astuce, désactiver l’enregistrement des fichiers journaux sur votre disque SSD. Pour cela, il faut demander au système de les inscrire en mémoire. Ceci permet d’éviter des écritures sur le disque SSD, ce qui présente trois avantages:
-
* une usure réduite du disque SSD,
* une consommation électrique plus faible,
* un système plus réactif.
Par contre, il y a un inconvénient : les journaux sont perdus lorsque la machine est redémarré. Bon, c’est un portable et pas un serveur donc ce n’est pas vraiment génant.
Pour rediriger en mémoire les fichiers journaux, j’ai édité le fichier /etc/fstab et ajouté les lignes suivantes :
tmpfs /var/log tmpfs defaults 0 0 tmpfs /tmp tmpfs defaults 0 0 tmpfs /var/tmp tmpfs defaults 0 0
Pour appliquer ces changements, il faut redémarrer la machine. La commande df -h permet de vérifier que tout fonctionne bien.
eee-applet, tu installeras
Enfin, pour exploiter au mieux les ressources de la batterie, j’ai également installé l’applet eee-applet qui permet d’activer/désactiver les différents périphériques du eeePC 701, de gérer les performances du microprocesseur et de fixer la vitesse de rotation du ventilateur.
apt-get install eee-applet
Des petits conseils, tu suivras
Pour une autonomie maximale, il ne faut pas oublier de désactiver les enceintes intégrées, de couper le WIFI et de baisser la luminosité de l’écran. Les périphériques USB (souris, clés, etc.) sont également des consommateurs d’énergie.
Ah ! mon eeePC 701 est vraiment formidable. Nous ne sommes pas prêt de nous quitter ;-)