-[ MaGaLoMa ]-

Emacs and J2EE on OSX notes

2011-10-07T09:16:00.001+02:00

Here's how I've managed to setup Emacs for J2EE / Tomcat / Maven application development on OSX.

Install Emacs

I use Emacs 23.3 from Emacs for OSX.

Malabar mode

Malabar mode offers easy code navigation, Maven, JUnit and Groovy integration. Download release 1.4 and extract in a directory to build it.

As the build will invoke emacs in batch mode, be sure that Emacs 23.3 is in your path (instead of using the one packaged with OSX).

What works on my machine:

unzip espenhw-malabar-mode-malabar-1.4.0-0-g35e1e5e.zip
cd espenhw-malabar-mode-1daaee4
export PATH=/Applications/Emacs.app/Contents/MacOS:$PATH
mvn package -DskipTests=true

Now in target directory there's a malabar-1.4.0-dist.zip. Unzip it where you put all your emacs librairies:


cd ~/.emacs.d/
unzip /path/to/malabar/target/malabar-1.4.0-dist.zip

Configure Emacs for Malabar

Open your .emacs and add:

(add-to-list 'load-path (expand-file-name "~/.emacs.d/malabar-1.4.0/lisp/")) 

(require 'cedet)
(require 'malabar-mode)
(setq malabar-groovy-lib-dir "/path/to/malabar/lib")
(add-to-list 'auto-mode-alist '("\\.java\\'" . malabar-mode))

(semantic-mode 1)
(require 'malabar-mode)
(setq malabar-groovy-lib-dir "~/.emacs.d/malabar-1.4.0/lib"
      malabar-load-source-from-sibling-projects t
      malabar-extra-source-locations
      '( "/absolute/path/to/project1/src" 
        "/absolute/path/to/project2/src" ) ) ;; you need to setup this 

(add-to-list 'auto-mode-alist '("\\.java\\'" . malabar-mode))

(add-hook 'malabar-mode-hook
     (lambda () 
       (add-hook 'after-save-hook 'malabar-compile-file-silently
                  nil t)))

Now open a .java file within Emacs.

Try malabar-jump-to-thing on one of your class and it should open the corresponding file.

Open a test file and try malabar-run-test. It should run maven test for this file. If all tests OK but finished with "BUILD FAILURE", then see next section

Java troubleshooting

Malabar should use java from jdk, not jde. I've tried setting JAVA_HOME and configure malabar without success. So quick dirty hack is:


cd /usr/bin
mv java java.jre
ln -s  /System/Library/Java/JavaVirtualMachines/1.6.0.jdk/Contents/Home/bin/java

Ressources

Entreprise Java Development With Emacs

Debugging Tomcat

Install JDIBug.In jdibug-expr.el, change the line (and to forget to byte-recompile or remove .elc):

(require 'semantic-java)

(require 'semantic/java)

Configure emacs:


(add-to-list 'load-path "~/.emacs.d/jdibug-0.5")
(setq jdibug-connect-hosts (quote ("localhost:8000"))
      jdibug-use-jde-source-paths nil
      jdibug-source-paths
      (list
			 "/path/to/project1/src" 
			 "/path/to/project2/src"  ))
(require 'jdibug)

Start Tomcat like with debugger enabled:

./bin/catalina.sh jpda start

Then try jdibug-connect to attach Emacs to tomcat.

TWM: Docking Windows

2011-07-12T23:49:00.000+02:00

Using Pharo 1.4 and latest TWM packages, you can now group windows as tabs.

Use:

(ConfigurationOfTilingWindowManager project 
    version: #bleedingEdge) load

My Pharo image

2011-06-28T08:01:00.002+02:00

Backup of my preferences:

Gofer it
   squeaksource: 'MetacelloRepository';
   package: 'ConfigurationOfPhexample';
   package: 'ConfigurationOfAutotest';
   squeaksource: 'TilingWindowManager';
   package: 'ConfigurationOfTilingWindowManager';
   load.
 
(Smalltalk at:#ConfigurationOfTilingWindowManager) perform: #loadDevelopment.
(Smalltalk at:#ConfigurationOfPhexample) load.
((Smalltalk at:#ConfigurationOfAutotest) project version: #development) load: 'OB'.

(Smalltalk at:#TWMUITheme) beCurrent. 
TaskbarMorph  showTaskbar: false.
TasklistMorph keepOpen: true.
(Smalltalk at:#TWMBar) perform: #showTWMBar: with: true.
(Smalltalk at: #AutotestDashboard) perform: #showAutotestDashboard: with: true.

Albaaaaaator, Albaaaaaaator, capitaine au coeur d'or ......

2011-06-11T13:40:00.002+02:00

Le papa d'Albator / Captain Harlock, Lieji Matsumoto, était à Annecy pour le festival d'animation.... on a la dédicace !!!

Nostalgie ....

Générique Albator 84 par MigXIII

Multiple Worlds for TWM

2011-06-07T22:29:00.001+02:00

With the help of my local developper group, I've integrated Sean DeNigris work and now Tiling Window Manager supports Multiple Worlds.

Here's a screencast that shows the progress. (My English seems a little less catastrophic than the previous screencast :)

Note: The tests failing on the screencast (Pharo 1.2) are green on Pharo 1.3.

Load TWM with:

Gofer it
  squeaksource: 'TilingWindowManager';
  package: 'TWM';
  load.

And ConfigurationOfKeyMapping 1.7 (TWM do not work with 1.8 actually) with:

Gofer it
    squeaksource: 'ShortWays';
    package: 'ConfigurationOfKeymapping';
    load.
    
(ConfigurationOfKeymapping project version: '1.7') load.

Tiling Window Manager

2011-05-28T00:03:00.003+02:00

I love Emacs because of editing speed and fast buffer switching among a lot neat features.

This week I've tried to make Pharo a little better on window management. This video shows the progress (thanks Gastón and Patrick for help and ideas).

Next step: KeyMapping integration + history à la Emacs winner-mode.

Sorry for my soooooooo awful english (tired ....).

Update 05/31/2011: you can load last version with colored theme with:

Gofer it
  squeaksource: 'TilingWindowManager';
  package: 'TWM';
  load.
(Smalltalk at: #StandardUITheme) beCurrent.
(Smalltalk at: #TWMBar) showTWMBar:true.

Tested on PharoCore 1.2 and Pharo 1.3.

Now this has support for world snapshot, that means you can arrange the windows and take a snapshot of the layout. Then you can restore these layouts later. (icons camera, <, > and trash). I'm not entirely satisfied with this, thanks for feedback.

In Pharo 1.3 there's initial integration with KeyMapping. To load:

Gofer it
  squeaksource: 'ShortWays';
  package: 'ConfigurationOfKeymapping';
  load.

(Smalltalk at: #ConfigurationOfKeymapping project version: '1.7') load.

Then in settings browser > Keymappings > Tiling Window Managers you have all actions of the dock mapped.

You can choose a Layout Strategy in settings.

Actually there's Horizontal (default) and Vertical (last used windows fills all remaining space) strategies.

To add your own just subclass TWMLayoutStrategy and implement #tileWindows:

To load TWM:

Gofer it
 squeaksource: 'TilingWindowManager';
 package: 'TWM';
 load.

I also think the UI theme Patrick has cleaned fits better with TilingWM:

Gofer it
 squeaksource: 'PBASandbox';
 package: 'PBSandbox';
 load.
 
StandardUITheme beCurrent.

Pomodoro scripts

2011-04-14T09:22:00.000+02:00

Sous OSX j'utilise ce logiciel comme chronomètre qui a l'avantage de pouvoir exécuter des scripts lorsque le Pomodoro démarre, s'arrête, ....

Au travail on utilise beaucoup la messagerie instantanée. J'utilise Adium comme client.

Besoins:

je ne veux pas être dérangé pendant mon Pomodoro (passer mon état à indisponible)
je veux que mes collaborateurs sachent quand se termine mon Pomodoro pour me contacter

Solution:

Dans Adium créer un statut indisponible avec comme titre'Pomodoro en cours'

Dans les préférences de Pomodoro, onglet script, configurez comme ceci:

Start:

tell application "Adium" to set the status of every account whose status type is available to the first status whose title is "Pomodoro en cours"

Reset et End:

tell application "Adium" to set the status of every account whose status type is away to the first status whose title is "Disponible"

Every 2 mins:
tell application "Adium" to set status message of every account to "Pomodoro en cours, fin dans $time mn"

Tout le long du Pomodoro votre statut sera mis à jour:

Et dès que quelqu'un ose vous contacter, réponse automatique !

Petite Horloge revisited

2011-04-13T16:08:00.006+02:00

Another Pharo Smalltalk snippet with temp classes (I like this :)

(Class new
    superclass: StringMorph;
    setFormat: StringMorph format;
    compile: 'step self contents: Time now printString';
    new)
        openInWindowLabeled: 'Petite Horloge'.

Don't forget the setFormat: or the VM will crash.Some explanations.

Polymorph counter example

2011-04-13T13:44:00.006+02:00

I've discovered that I can write this in Pharo:

"This creates a class and one instance on the fly"
counter := Class new 
              superclass: Object; 
              addInstVarNamed: 'counter'; 
              compile: 'initialize 
                           counter := 0';
              compile: 'counterString 
                           ^ counter asString';
              compile: 'increment 
                           counter := counter + 1. 
                           self changed:#counterString';
              compile: 'decrement 
                           counter := counter - 1. 
                           self changed:#counterString';
              new.

(UITheme builder newColumn: {
  UITheme builder newLabelFor: counter getLabel: #counterString getEnabled: nil.
  UITheme builder newRow: {
    UITheme builder newButtonFor: counter action: #increment label: '+' help: nil.
    UITheme builder newButtonFor: counter action: #decrement label: '-' help: nil.
  }
}) openInWindowLabeled: 'Counter example'.

Coooooooooooooool ;)

Multiple worlds for Pharo

2011-03-19T09:28:00.001+01:00

Sean DeNigris submitted a changeset to get multiple worlds in Pharo.

I've played a little with it to get a world switcher. If you want it, first file in the changeset file (download it the drag the file on an opened image).

Then the following code add three worlds named 2,3,4 and create a dock in each world.

|wm|
wm := WorldManager instance.
#('2' '3' '4') do: [:aString| wm createOrSwitchToWorldNamed: aString].

wm worlds keysAndValuesDo:  [:aWorldName :aWorld| |dock|
  dock := DockingBarMorph new
          adhereToTop;
          openInWorld: aWorld.

  wm worlds keysAndValuesDo: [:aWorldName2 :aWorld2|
    dock addMorph: (SimpleButtonMorph new
                    label: aWorldName2;
                    target: [wm createOrSwitchToWorldNamed: aWorldName2];
                    actionSelector: #value) ].
                    
  dock addMorph: (StringMorph contents: aWorldName).
].

Work on Mocketry

2011-02-28T22:23:00.000+01:00

Mocketry is a Mocketry is Smalltalk mock object framework.

To load it in Pharo:

Gofer it
  squeaksource: 'MetacelloRepository';
  package: 'ConfigurationOfMocketry';
  load.

(Smalltalk at:#ConfigurationOfMocketry) project latestVersion load.

I've done the first part of the Picasa screencast in a TDD way using Mocketry to prevent external HTTP requests.

Gofer it
 squeaksource: 'LaurentLSandbox';
 package: 'Picasa';
 load.

As the requests are done using HTTPSocket class>>httpGet:, one way is to give a mock to PicasaSearch so we can check (and stub) the HTTP request:

PicasaSearchTwoRoughSeaTest>>setUp
  [:mockHTTPSocketClass|
    [photos := PicasaSearch new
        httpSocketClass: mockHTTPSocketClass;
        addKeyword: 'rough';
        addKeyword: 'sea';  
        maxResult: 2;
        photos.] 
 
     should strictly satisfy: [
        (mockHTTPSocketClass httpGet: 
          'http://picasaweb.google.com/data/feed/api/all?q=rough+sea&max-results=2')
        willReturn: self fixtureXMLResponseForTwoRoughSea] 
  ] runScenario.

#fixtureXMLResponseForTwoRoughSea will return an XML string and test methods will check that it is correctly parsed.

In PicasaSearch:

httpGetDocument 
  |url| 
  url := String streamContents: [:aStream|
  aStream 
    nextPutAll: 'http://picasaweb.google.com/data/feed/api/all?q=';
    nextPutAll: ('+'  join: self keywords);
    nextPutAll: '&max-results=';
    nextPutAll: self maxResult asString.    
  ].  

  ^ (self httpSocketClass httpGet: url).

See that mocketry extends BlockClosure to create mocks:

[:myFirstMock :mySecondMock|
"do stuff with mocks"
] runScenario

and set up expectations:

[:myFirstMock :mySecondMock|
  [ "do stuff with mocks" ] 
  should strictly satisfy: 
  [ "what is expected on mocks" ]  
] runScenario

See HelpSystem book loaded with Mocketry for several examples.

Comments and better code propositions are welcome.

XML Browser with Pharo

2011-02-21T18:37:00.001+01:00

I've written a little tool to help me browse xml. If you want to try it:

Gofer new
 squeaksource: 'LaurentLSandbox';
 package: 'XML-GUI';
 load.
 
((Smalltalk at:#XMLBrowser) labelled: 'Picasa search')
  browseAtUrl: 
   'http://picasaweb.google.com/data/feed/api/all?q=lighthouse&max-results=10'.

See XMLBrowser comment for examples.

FizzBuzz Kata: minimal solution

2011-02-18T07:57:00.004+01:00

Trying to find a minimal solution for the FizzBuzz Kata in Smalltalk:

fb := [:counter| |rules|
       rules := {15->'FizzBuzz'. 5->'Buzz'. 3->'Fizz'. 1->counter}.
       rightRule := rules detect: [:aRule| counter \\ aRule key == 0].
       rightRule value].  

self assert: (fb value: 7) == 7.
self assert: (fb value: 3) == 'Fizz'.
self assert: (fb value: 5) == 'Buzz'.
self assert: (fb value: 15) == 'FizzBuzz'.

1 to: 100 do: [:counter | 
               Transcript 
                 show: (fb value: counter) asString;
                 cr]

Update: Little variant from Alexandre:rightRule := rules detect: [:aRule| counter isDivisibleBy: aRule key]

Smalltalk tiny exercise for TDD newbies

2011-02-08T07:45:00.002+01:00

Done in course:

Create the category Exercise in the Browser. All classes you create will be placed in this category.

Implement the class Operation (using Test-Driven Development) which should work like this:

a := Operation new. a result.Should return 0.

b := Operation new.
b add: 2.
b add: 3.
b result.

Should return 5.

Operation new
  add: 2;
  add: 4;
  divideBy: 2;
  result.

Should return 3.

Add the message Operation>>#multiplyBy by yourself.

new funny ProfStef lesson

2011-02-06T19:31:00.002+01:00

Update to last ProfStef (on Pharo 1.2 only):

Gofer it
 squeaksource: 'MetacelloRepository';
 package: 'ConfigurationOfProfStef';
 load.
 
ConfigurationOfProfStef project latestVersion load.

ProfStef 
  go;
  tutorial: SmalltalkSyntaxTutorial lesson: #instanciation.

Why technology matters

2011-02-02T09:12:00.000+01:00

Life is very short. You have a limited amount of time in which to realize your dreams, in which to do your projects. If you’re like me, you probably have dozens and dozens of ideas for apps, sites, portals, that you want to implement. Most of those ideas will suck. But you don’t know which ones, you won’t know until you try them. Your goal, in this life, is to iterate faster. To fail more, to fail quicker, until you get to the brilliant ideas and brilliant projects that can change the world, or at least make you a dollar or two.

From A Secret: Passion and Your Choice of Web Framework by Dmitri Zagidulin

Smalltalk à l'OSDC.fr 2010

2011-01-28T08:07:00.000+01:00

Et là j'ai peur en me voyant en vidéo ....

Pharo GUI with Polymorph

2011-01-25T22:06:00.005+01:00

I've written a tiny address book to prepare a screencast on Polymorph basis. If you want to look at it:

Gofer it
 squeaksource: 'Pharocasts';
 package: 'ContactManager';
 load.
 
(Smalltalk at:#ContactListEditor) open.

Start by looking how the contact list is built:

ContactListEditor>>open
  |builder content|
  builder := UITheme builder.
  content := builder newColumn: {   
        builder 
                newListFor: self   
                list: #contacts
                selected: #contactSelectedIndex
                changeSelected: #contactSelectedIndex:
                help: 'contacts'.
        builder newRow: {
                builder newButtonFor: self 
                        action: #addButtonClick 
                        label: 'Add' 
                        help: 'Create a new contact'.
                builder newButtonFor: self 
                        action: #removeButtonClick 
                        getEnabled: #hasSelectedContact 
                        label: 'Remove' 
                        help: 'Remove selected contact'.
                builder newButtonFor: self 
                        action: #editButtonClick 
                        getEnabled: #hasSelectedContact 
                        label: 'Edit' 
                        help: 'Edit selected contact'  }}.
   
  (content openInWindowLabeled: 'Contacts') extent: 400@500.

#newRow: and #newColumn: are an easy way to align elements on the window.

When the Add button is clicked, message #addButtonClick is sent on the ContactListEditor object:

ContactListEditor>>addButtonClick
  |newContact|
  newContact := Contact new.
 
  ContactEditor new
        contact: newContact;
        onOK: [ Contact database add: newContact.  
                selectedContactIndex := Contact database size.
                self 
                        changed: #contacts;
                        changed: #hasSelectedContact];
        openModal.

The closure given to onOK: adds the new Contact and tells the view to refresh components which depends on #contacts and #hasSelectedContact selectors - that means the contact list and the Remove and Edit buttons.

ContactEditor defines a modal dialog to edit the firstName and lastName of a Contact:

ContactEditor>>openModal
  |builder dialog content firstName|
  
  builder := UITheme builder.
  content := (builder newLabelGroup: {
                'First name' -> (
                       firstName := (builder
                         newTextEntryFor: contact
                         getText: #firstName
                         setText: #firstName: 
                         help: 'Enter the first name of the contact')
                       acceptOnCR: false;
                       minWidth: 200).
                'Last name' -> (
                       (builder
                          newTextEntryFor: contact 
                          getText: #lastName 
                          setText: #lastName: 
                          help: 'Enter the last name of the contact')
                        acceptOnCR: false;
                        minWidth: 200) }).
 
  dialog := builder 
              newPluggableDialogWindow:'Edit contact' 
              for: content.
  dialog rememberKeyboardFocus: firstName.
  builder openModal: dialog.
 
  dialog cancelled ifFalse: [self doOnOK].

From Gary Chambers (and thanks !):

Disabling the acceptOnCR for each text frield allows the default dialog handling for the return key (defaults to OK).

Normally the initial keyboard focus for a dialog is the default button, if specified. Remembering the first name field prior to opening will give that field focus.

Now it should be easier to understand Polymorph examples found in
UITheme class>>exampleBasicControls and friends (in examples protocol).

CodeRetreat à Grenoble

2011-01-24T10:35:00.007+01:00

Vendredi dernier je me suis rendu au premier CodeRetreat en France organisé par Johan Martinsson, Remy Sanlaville et Miguel Moquillon, avec le soutien du CARA et Alpes JUG - merci tout le monde !

En résumé, le CodeRetreat consiste à enchaîner des itérations d'une heure en pair-programming et Test-Driven Development sur le même problème tout au long de la journée. Le problème choisi était le jeu de la vie, qui a les avantages d'offrir plusieurs approches possibles et d'être assez complexe pour ne pas être résolu en 45mn.

Chaque itération se déroule de la manière suivante:

Constitution des binômes (on change à chaque itération).
45mn de programmation.
15mn de rétrospective.

C'est agile, le temps est chronométré (belle organisation).

A la fin des 45mn de programmation, le code est effacé. Comme l'a répété Johan, ce n'est pas le résultat qui compte, mais la démarche, l'approche du développement qu'on doit s'efforcer de faire le plus parfaitement. C'est à dire:

développement piloté uniquement par les tests
pas de duplication de code
noms clairs et significatifs
code le plus simple possible

Côté langages nous avions beaucoup de Java. Miguel et moi en avons profité pour faire découvrir Pharo / Smalltalk et faire une session ensemble en Haskell. Il y a aussi eu un peu de Ruby.

Les 15mn de rétrospective permettaient d'échanger sur les différentes approches, les difficultés rencontrées, succès. On voit bien qu'il y a plusieurs manières d'attaquer le problème. Au fur et à mesure des automatismes se mettent en place ce qui permet de gagner du temps pour aborder d'autres aspects du problème.

Suit ce que j'en retire.

Pair-programming:

Chaque session se déroulait avec un binôme différent et chaque expérience, démarche a du coup été significativement différente. J'ai rencontré plusieurs cas:

une personne qui a l'idée et une autre qui suit: c'est du coup souvent la personne qui veut voir son idée réalisée qui pilote et qui tape. La personne qui suit dépense beaucoup d'énergie pour rester dans le coup (j'ai été dans cette position sur une session). Il est nécessaire que la personne qui pilote temporise.
deux personnes qui ont des idées: cela amène assez vite a quelques débats sympathiques mais c'est l'expérience qui me semble la plus enrichissante, d'où émerge des solutions de type "waouh, ça c'est cool".
deux personnes ont la même idée, suivent la même route: dans ce cas c'est plus la volonté de bien faire qui ressort et la recherche de qualité / perfection dans la démarche est vraiment élevée

Dans tous les cas, il y a toujours une bonne ambiance à coder avec des inconnus :)

Test-Driven Development:

Je suis convaincu de la démarche et la pratique depuis que j'ai lu eXtreme Programming de Kent Beck vers 2002/2003. Donc je fais partie des gens qui ont des automatismes assez arrêtés sur le sujet :). Pour avoir vu d'autres façons de faire au cours de la session, je reste persuadé que la manière la plus claire est d'avoir:

un TestCase par contexte. Le setUp établit le contexte, les tests font les vérifications.
un assert par test. Avoir plusieurs assert doit rester exceptionnel car ça complexifie les tests (ce n'est pas interdit, mais il faut avoir conscience du compromis).

Un exemple concret est la règle: "Si une cellule a exactement deux voisines vivantes, elle reste dans son état actuel à l’étape suivante".

Avec Rémy nous avons codé comme suit (grosso modo, le code a été effacé :)

ALivingCellWithTwoOrThreeLivingNeighbours>>#testShouldLive
  |aliveCell|
  aliveCell := Cell new revive.
  self assert: aliveCell isAlive.

  2 to: 3 do: [:numberOfNeighbours|
    aliveCell numberOfNeighbours: numberOfNeighbours.
    self assert: aliveCell shouldLive.
  ]

Le soucis c'est que quand le test est en échec, il faut débugger pour savoir si ça coince pour deux ou trois cellules.

Dans ce cas je préfère avoir deux cas:

ALivingCellWithTwoLivingNeighbours
ALivingCellWithThreeLivingNeighbours

Ceci dit cela risque d'amener une duplication de code, vu que les tests sont identiques dans chaque cas. Une solution codée avec Aline est d'utiliser des Traits pour définir les tests de manière générique puis de mettre seulement les différences dans les TestCase.

Trait named: #TCellIsAliveAndShouldLive

TCellIsAliveAndShouldLive>>#testIsAlive
  self assert: self aliveCell isAlive

TCellIsAliveAndShouldLive>>#testShouldLive
  self assert: self aliveCell shouldLive

TCellIsAliveAndShouldLive>>#aliveCell
   self explicitRequirement

Du coup pour nos cas de test:

TestCase subclass: #ALivingCellWithTwoLivingNeighbours
  uses: TCellIsAliveAndShouldLive

ALivingCellWithTwoLivingNeighbours>>#aliveCell
  ^ Cell new
       revive;
       numberOfNeighbours: 2.

de même:

TestCase subclass: #ALivingCellWithThreeLivingNeighbours
  uses: TCellIsAliveAndShouldLive

ALivingCellWithThreeLivingNeighbours>>#aliveCell
  ^ Cell new
        revive;
        numberOfNeighbours: 3.

Approches

Les deux approches principales consistaient à commencer par implémenter la Cellule ou bien la Grille / Univers. Il était aussi possible de passer par une classe Neighbours intermédiaire.

Haskell qui est un langage fonctionnel permet d'avoir une approche par les ensembles.

Une solution liée à l'imagerie en travaillant en binaire a été évoquée mais pas implémentée à ma connaissance.

Pour simplifier l'algorithme qui calcule si la cellule doit vivre ou mourir en connaissant son état actuel et le nombre de ses voisins vivants, deux variantes:

avoir deux classes LiveCell et DeadCell qui ont chacune leur algorithme
implémenter le pattern strategy et donc un objet Cell utiliserait soit un DeadCellStrategy, soit un LiveCellStrategy. Ceci à l'avantage de ne pas avoir à changer le type des instances dans la grille

Avec Smalltalk une solution utilisée pour implémenter le pattern strategy se basait sur les Closures et évitait de créer des classes supplémentaires:

  Cell>>#liveCellStrategy
    ^ [(liveNeighbours < 2) or: [ liveNeighbours > 3 ]]

  Cell>>#deadCellStrategy
    ^ [(liveNeighbours = 3) not]

  Cell>>die
    shouldDieStrategy := self deadCellStrategy

  Cell>>revive
    shouldDieStrategy := self liveCellStrategy

  Cell>>#shouldDie
    ^ shouldDieStrategy value

Bilan

Journée enrichissante et éreintante. La retrospective finale en a un peu pâti vu que tout le monde était fatigué. Une proposition d'amélioration qui me plaît est de découper la session de 45mn en deux pomodoro de 20mn pour ménager notre énergie.

Quelques "Smalltalk c'est cool" font plaisir ;)

En tout cas je reste convaincu par l'approche pair-programming qui est trés enrichissante et donne du courage pour explorer de nouvelles pistes et aller plus vite (car on se perds moins).

C'est dans ces moments là qu'on sent que la programmation est un artisanat au sens noble du terme, où la beauté du résultat est une source de motivation.

Par @bootis quality = you know why it works

Le compte-rendu de Johan

PharoConf Annecy 2011

2011-01-14T07:56:00.000+01:00

La première PharoConf Annecy aura lieu le jeudi 10 février à l'IMUS.

Site web de l'évènement: http://pharoconf-annecy.seasidehosting.st/

Les interventions seront plus tournées vers des coding-dojo et ateliers, développer du vrai code qui tourne :)

Deux points forts:
- Randori Test-Driven Development animé par Miguel Moquillon du Club Agile Rhône Alpes
- PharoSprint animé par Stéphane Ducasse

Entrée gratuite, mettez à jour vos agendas !

(Et merci de faire passer le message :)

Petite horloge

2011-01-10T22:42:00.000+01:00

Morphic basics with a little Watch (Horloge in french).

Add the class:

StringMorph subclass: #Horloge
 instanceVariableNames: ''
 classVariableNames: ''
 poolDictionaries: ''
 category: 'Sandbox'

One method called periodically thanks to stepping mechanism of Morphic:

Horloge>>step
 self contents: Time now printString.

Then evaluate in a Workspace: Horloge new openInWorld.

Stop the watch: Horloge allInstances last stopStepping

Start it again:Horloge allInstances last startStepping

Finally close it:Horloge allInstances last delete

My cat is a Linux geek :)

2010-12-04T09:30:00.000+01:00

Revenge of Smalltalk

2010-11-28T09:41:00.008+01:00

(Joke inside)

In Paul Graham's essay Revenge of the Nerds (Read it, good ideas there):

Appendix: Power

As an illustration of what I mean about the relative power of programming languages, consider the following problem. We want to write a function that generates accumulators-- a function that takes a number n, and returns a function that takes another number i and returns n incremented by i.

(That's incremented by, not plus. An accumulator has to accumulate.)

In Common Lisp this would be

(defun foo (n)
  (lambda (i) (incf n i)))

In Smalltalk the code is slightly longer than in Lisp:

foo: n                              
  |s|                      
  s := n.                          
  ^[:i| s := s+i. ]

because although in general lexical variables work, you can't do an assignment to a parameter, so you have to create a new variable s.

Well, the Lisp code has 34 significant characters while the Smalltalk code has only 25 significant characters (we can remove the last dot). So the Smalltalk code is 26% shorter than the Lisp code :)

Perl example: 32 characters
Javascript example: 46 characters
Python example: 54 characters

Yeah, Smalltalk is really powerful ;P

Update:
Looking at Parser code we can easily remove the temp. variable limitation and write:

foo: n               
  ^[:i| n := n+i]

One power of Smalltalk is to be able to change the system.
17 significant characters: Smalltalk 100% more powerful than Lisp :D

Why this design decision ? Some explanation from Nicolas and Adrian.

Three views of OO Programming

2010-10-28T14:01:00.004+02:00

By Ralph Johnson, quoted in The Myths of Object-Orientation p.624:

I explain three views of OO programming. The Scandinavian view is that an OO system is one whose creators realise that programming is modelling. The mystical view is that an OO system is one that is built out of objects that communicate by sending messages to each other, and computation is the messages flying from object to object. The software engineering view is that an OO system is one that supports data abstrac- tion, polymorphism by late-binding of function calls, and inheritance.

It seems that in (French) schools we learn the engineering view. Then with experience we can agree on the mystical view. With Smalltalk I think I now understand the Scandinavian view.

Oscar Nierstrasz have written in Ten Things I Hate About OOP:

For me the point of OOP is that it isn’t a paradigm like procedural, logic or functional programming. Instead, OOP says “for every problem you should design your own paradigm”. In other words, the OO paradigm really is: Programming is Modeling

Autotest for Pharo

2010-06-18T12:08:00.002+02:00

I've started a new little project. Autotest is a live testing tool (similar to Ruby Autotest, but the Smalltalk way, more dynamic).

Autotest automatically runs tests related to the method you edit. Screencast to see it in action:

Autotest uses the following heuristics to find the tests to run:

- if the method is a test, runs it

- it the method is a test setUp or tearDown, run all the tests of the TestCase

- else find all senders which are tests in the same package and runs them (it detects different packages that are related, for example ProfStef-Core and ProfStef-Test)

To activate the Autotest dashboard:

- open the settings browser

- go under System

- check "Show Autotest Dashboard" option

To load it:

Gofer new

squeaksource: 'Autotest';

package: 'Autotest';

load

HelpSystem book included.

GNU/Linux install party des Savoie

2010-05-15T13:20:00.000+02:00

Une grande Install Party des Savoie aura lieu le samedi 22 mai et - évènement unique - simultanément sur Chambéry (MJC Résidence Escoffier, 379 fbg Montmélian) et sur Annecy (CDDP, 2 rue des Aravis) de 10h à 17h (les associations seront sur place 1 heure avant).

La distribution retenue pour une installation grand public est Ubuntu 10.04 'Lucid Lynx' LTS, et ses dérivés au cas où matériel le nécessiterai.

Chambéry et Annecy seront reliées en vidéo via EKIGA (sous réserve d'essais préalables concluants).

L'annonce de l'Install-Party est diffusée sur les radio locales (France Bleu Pays de Savoie, ODS Radio, Montagne FM) et est relayée dans la presse par le Dauphiné Libéré. Des affiches sont également diffusées dans les villes.

easy_squeakvm on github

2010-04-20T22:44:00.000+02:00

I've created my first repository on github. So easy!

easy_squeakvm is used to build the squeak vm from scratch on Linux in one command.
To build the VM, just get the the script and execute

./easy_squeakvm.sh

This will

checkout squeakvm sources from svn repository
download PharoCore image
load VMMaker into PharoCore
generate the interpreter
build the VM
put binaries in out/squeakvm, ready to use

I was tired of typing the same commands over and over :)

http://github.com/lolgzs/easy_squeakvm

How I build squeak vm on (Arch)Linux

2010-03-10T23:10:00.004+01:00

I write this post as a memento for me. I will appreciate some feedback on building the VM on other Linux distro.

1. Prepare a working directory

All the work will take place in ~/squeakvm (/home/lol/squeakvm on my machine):

mkdir ~/squeakvm
cd ~/squeakvm

2. Get squeak-vm source

The easiest part. The VM source code tarball can be found on http://www.squeakvm.org/unix/. At the time of writing, the last stable version is 3.11-3.2135. Go and get it:

wget http://www.squeakvm.org/unix/release/Squeak-3.11.3.2135-src.tar.gz
tar -xvzf Squeak-3.11.3.2135-src.tar.gz

3. Load VMMaker tool

For more explanations on why VMMaker is needed and how it works, here is a good overview.

To generate the source code for your own VM, you need a running Pharo image. Here I use a fresh Pharo 1.0-10508 rc2 image from Pharo website.

Open your image, then load VMMaker by evaluating this in a Workspace:

Gofer new
 squeaksource: 'MetacelloRepository';
 package: 'ConfigurationOfVMMaker';
 load.
 
(Smalltalk at:#ConfigurationOfVMMaker) project lastVersion load.

4. Load FT2Plugin

UPDATE: Should not be necessary now. See Javier's comment.

To display anti-aliased font of Pharo images, you need the FT2Plugin. To load it:

MCHttpRepository
 location:'http://www.squeaksource.com/FreeTypePlus'
 user: ''
 password: ''.

MCHttpRepository
 location: 'http://source.impara.de/freetype'
 user: ''
 password: ''.

5. Configure VMMaker and generate the VM source

Now you can open VMMakerTool:

VMMakerTool openInWorld

In the Path to platforms field put the path to the extracted Squeak VM tarball: ~/squeakvm/Squeak-3.11.3.2135-src.

Then right-click on one of the plugins pane and select make all external for a simple configuration.

Note you can have a description of each plugin by reading the class comment.Classes are part of VMMaker-Plugins category.

In path to generated source select a directory where the VM source will be written. Here ~/squeakvm/src32.

The VMMakerTool window should look like this:

Then click on the Entire button (top-left of window). Wait a moment, pray, and the code should be generated.

Finally, I replace the original VM source with the generated one.

rm -rf ~/squeakvm/Squeak-3.11.3.2135-src/unix/src
cp -a ~/squeakvm/src32 ~/squeakvm/Squeak-3.11.3.2135-src/unix/src

Note: theorically this should not be necessary as the configure script accepts an option to specify the source directory path, but it doesn't seem to work.

6. Build the VM

First create a directory for the build and go in:

mkdir ~/squeakvm/Squeak-3.11.3.2135-src/build
cd ~/squeakvm/Squeak-3.11.3.2135-src/build

Then run the configure script

../unix/cmake/configure

First problem. I have this error:

CMake Warning (dev) in 
/home/lol/squeakvm/Squeak-3.11.3.2135-src/build/=/CMakeLists.txt:
  Syntax error in cmake code when parsing string

    ${=_link_directories}

  syntax error, unexpected cal_SYMBOL, expecting } (21)

Thanks to this mail there's a patch to correct it.

cd ~/squeakvm/Squeak-3.11.3.2135-src/unix/cmake/
wget http://lolgzs.free.fr/pharo/Plugins.cmake.patch
patch -p0 < Plugins.cmake.patch

Then clean and run the configure script again

cd ~/squeakvm/Squeak-3.11.3.2135-src/build
rm -rf *
../unix/cmake/configure

You should have the Makefile now. Run make:

make

Then another problem as libfreetype (needed by FT2Plugin) is not found. To correct it, create config.cmake for FT2Plugin this way:

mkdir ~/squeakvm/Squeak-3.11.3.2135-src/unix/plugins/FT2Plugin/
echo "PLUGIN_FIND_LIBRARY(FT2 freetype)" > 
    ~/squeakvm/Squeak-3.11.3.2135-src/unix/plugins/FT2Plugin/config.cmake

More informations on this error here.

UPDATE: See Javier's comment.

Clean and run make again:

make clean
make

Then install:

sudo make install

7. Conclusion
The process is not so easy. To help I put all the squeakvm directory (with sources, pharo image with vmmaker) on http://lolgzs.free.fr/pharo/squeakvm.tar.gz

UPDATE: Good post for MacOSX

Pharo & Smalltalk party

2010-02-25T18:35:00.000+01:00

J'organise avec quelques confrères une "Pharo & Smalltalk party", dans l'objectif de faire découvrir et partager les expériences du développement Pharo et Smalltalk.

Que vous soyez développeur curieux ou Smalltalker expérimenté, rendez-vous le Samedi 20 Mars de 14h à 18h dans les locaux de Félix Création à Cran-Gévrier (bassin Annécien).

Voici le plan du lieu de rendez-vous.

Seaside-Hosting compatible Pharo

2010-01-30T19:15:00.001+01:00

L'hébergeur gratuit (pour des applications non-commerciales) Seaside-Hosting accepte maintenant les images Pharo ! J'en ai donc profité pour déployer ma première image Seaside... et c'est d'une simplicité étonnante.

Il suffit juste de créer un compte, uploader son image, clicker sur Start et c'est fini. Cool.

J'ai donc mis en ligne une image avec SimpleWebDoc: http://magaloma.seasidehosting.st/

Screencast sous Linux

2010-01-29T08:33:00.000+01:00

Après avoir essayé pas mal d'outils disponibles sous Linux pour réaliser des screencasts et alimenter Pharocasts, voici le contenu de ma boîte à outils du moment.

Pour enregistrer j'utilise Xvidcap. On définit une zone de capture et le mode multi-frame permet de générer la vidéo à la volée. Ma zone de capture est en 800x600, éviter les résolutions exotiques (garder du 4:3 ou 16:9). Dans le cas contraire on risque une perte importante de la qualité par les encodeurs et les sites de publication en ligne.
J'enregistre en avi/mpeg4.

Pour couper les scènes, j'aime bien Avidemux. Interfaces texte, GTK et Qt disponibles. Il s'appuie sur son propre fork de FFmpeg pour l'encodage et c'est très rapide si vous gardez le même format que la vidéo originale.

Pour encapsuler au format mov, car les possesseurs d'anciennes versions de MacOSX ont des soucis avec l'avi, j'utilise la commande suivante (qui ne doit pas être la meilleure, vu que le fichier généré double de taille pour une qualité moindre):

ffmpeg -i mavideo.mpeg -b 500k mavideo.mov

Je suis toujours à la recherche d'un outil sympa pour le montage, type Kdenlive, mais je n'ai encore rien trouvé qui me plaise vraiment.

Pour publier, entre Vimeo, YouTube et DailyMotion, c'est Vimeo que je préfère pour la qualité de la vidéo.

ProfStef news

2010-01-22T09:34:00.001+01:00

ProfStef est inclut dans le Metacello Repository. Metacello permet de spécifier les dépendances entre packages.

Cela signifie qu'il est maintenant assez simple de charger ProfStef et ses dépendances dans Pharo via Loader (l'équivalent d'apt-get pour Pharo):

Gofer new
        squeaksource: 'Loader';
        package: 'Loader';
        load.

Loader new load: 'ProfStef'.

Il est maintenant possible de créer son propre tutorial intéractif pour ProfStef. Comment ? Il y a un tutorial pour ça :).

Dans un Workspace, évaluez:
ProfStef goOn: HowToMakeYourOwnTutorial.

Smalltalk interactive tutorial

2010-01-18T21:14:00.003+01:00

ProfStef est un tutorial intéractif sur Smalltalk (un peu inspiré de Try Ruby).
L'objectif est d'apprendre les bases du langage Smalltalk de manière ludique.

Pour charger ProfStef dans votre image, évaluez le code suivant dans un Workspace:

Gofer new
    squeaksource: 'ProfStef';
    package: 'ProfStef';
    load.

Blog dédié à Pharo

2010-01-10T23:21:00.000+01:00

Je viens de mettre en ligne un blog qui me servira à publier et pointer des tutoriels vidéo sur Pharo. Ça s'appelle Pharocasts et c'est ici: http://pharocasts.blogspot.com/

GUI et Pharo

2010-01-08T20:44:00.005+01:00

J'ai fait une vidéo sur Pharo montrant les techniques de base pour disposer des éléments dans une fenêtre et répondre aux clics sur les boutons.

Voici un des exemples de code de la vidéo:

|aWindow aPanel buttonPanel|

aWindow := SystemWindow labelled: 'My first window'.

aPanel := PluggablePanelMorph new.
aWindow addMorph: aPanel fullFrame: (
    LayoutFrame
        fractions: (0@0 corner: 1@1)
        offsets: (0@0 corner: 0@50 negated)).
aPanel color: (Color blue).

buttonPanel := PluggablePanelMorph new.
aWindow addMorph: buttonPanel fullFrame: ( 
    LayoutFrame
        fractions: (0@0.99 corner: 1@1)
        offsets: (0@50 negated corner: 0@0)).
buttonPanel  color: (Color green).


#(one two three) do: [:label| |aButton| 
 aButton := PluggableButtonMorph new label: label; yourself.
 buttonPanel addMorph: aButton fullFrame: nil.
].


aWindow openInWorld.

Ruby 1.9, SQLite et UTF-8

2010-01-04T11:24:00.004+01:00

Comme abordé précédemment dans le billet Migrer vers Ruby 1.9, le gem sqlite3-ruby actuel (version 1.2.5) ne fonctionne pas vraiment avec des données UTF-8.

Un fork de la version 1.2.4 qui corrige ces problèmes est disponible ici: http://github.com/qoobaa/sqlite3-ruby.

Pour l'installer, clonez d'abord le repository avec git:

git clone git://github.com/qoobaa/sqlite3-ruby.git

puis allez dans le répertoire créé et construisez le gem:

cd sqlite3-ruby
gem build sqlite3-ruby.gemspec

si tout fonctionne vous avez maintenant le gem sqlite3-ruby-1.2.6.gem. Installez-le:

gem install sqlite3-ruby-1.2.6.gem

C'est tout pour Linux, sous Windows cela se complique étant donné que le gem intègre une extension C qu'il faut linker avec SQLite. Vous devriez donc tomber sur l'erreur:

Building native extensions.  This could take a while...
ERROR:  Error installing sqlite3-ruby:
        ERROR: Failed to build gem native extension.

ou si vous avec déjà installé le devkit:

checking for sqlite3.h... no

La suite nécessite d'avoir le devkit d'installé sur votre machine (voir http://rubyinstaller.org/download.html et http://wiki.github.com/oneclick/rubyinstaller/development-kit ).

Créez un répertoire qui contiendra les fichiers nécessaires à la compilation de l'extension, à savoir sqlite3.h (dans le sous-répertoire include) et sqlite3.dll (dans le sous-répertoire lib). Par exemple:

C:\Ruby19\sqlite3
            |- include
            |   |- sqlite3.h
            |- lib
                |- sqlite3.dll

Le fichier sqlite3.h se trouve dans les sources de SQLite: http://www.sqlite.org/sqlite-amalgamation-3_6_21.zip

Le fichier sqlite3.dll se trouve dans la distribution binaire pour Windows: http://www.sqlite.org/sqlitedll-3_6_22.zip

Modifiez ensuite la configuration de la compilation de l'extension pour inclure le répertoire créé. Ouvrez le fichier ext/sqlite3_api/extconf.rb des sources du gem et ajoutez la ligne suivante:

dir_config("sqlite3", "C:\\Ruby19\\sqlite3")

Vous pouvez maintenant regénérer le gem et l'installer:

gem build sqlite3-ruby.gemspec
gem install sqlite3-ruby-1.2.6.gem

Migrer vers ruby 1.9

2009-12-30T13:36:00.003+01:00

Je viens de migrer deux applications Rails 2.3.5 vers Ruby 1.9.1 avec deux problèmes majeurs concernant les encodings. Bien que Ruby soit unicode par défaut, pas mal de gems ne parlent pas l'UTF-8 par défaut...

Premier soucis avec ERB qui compile les templates en utilisant ASCII-8BIT par défaut. Cela génère l'erreur suivante:

ActionView::TemplateError (incompatible character encodings: ASCII-8BIT and UTF-8)

Il y a pas mal de discussions sur le sujet ici: https://rails.lighthouseapp.com/projects/8994/tickets/2188-i18n-fails-with-multibyte-strings-in-ruby-19-similar-to-2038

Une solution hacky à coup de monkey patch est de créer un fichier lib/actionview_utf8 comme ceci (c'est la ligne avec le source.force_encoding qui est rajoutée au code original):

module ActionView
  module Renderable #:nodoc:
    private
      def compile!(render_symbol, local_assigns)
        locals_code = local_assigns.keys.map { |key| "#{key} = local_assigns[:#{key}];" }.join

        source = <<-end_src
          def #{render_symbol}(local_assigns)
            old_output_buffer = output_buffer;#{locals_code};#{compiled_source}
          ensure
            self.output_buffer = old_output_buffer
          end
        end_src
        source.force_encoding(Encoding::UTF_8) if source.respond_to?(:force_encoding)

        begin
          ActionView::Base::CompiledTemplates.module_eval(source, filename, 0)
        rescue Errno::ENOENT => e
          raise e # Missing template file, re-raise for Base to rescue
        rescue Exception => e # errors from template code
          if logger = defined?(ActionController) && Base.logger
            logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
            logger.debug "Function body: #{source}"
            logger.debug "Backtrace: #{e.backtrace.join("\n")}"
          end

          raise ActionView::TemplateError.new(self, {}, e)
        end
      end
  end
end

puis d'ajouter les lignes suivantes à environnement.rb:

Rails::Initializer.run do |config|
  ...
  config.after_initialize do 
    require 'lib/actionview_utf8'
  end
end

Ensuite je suis tombé sur le problème des adaptateurs aux bases de données qui retournent de l'ASCI-8BIT au lieu d'UTF-8 à la lecture des données. Une solution du même acabit est décrite ici: http://gnuu.org/2009/11/06/ruby19-rails-mysql-utf8/. Ceci dit ça ne fonctionne qu'avec MySql.

Donc on créé le fichier lib/mysql_utf8:

require "mysql"

class Mysql::Result
  def encode(value, encoding = "utf-8")
    String === value ? value.force_encoding(encoding) : value
  end

  def each_utf8(&block)
    each_orig do |row|
      yield row.map {|col| encode(col) }
    end
  end
  alias each_orig each
  alias each each_utf8

  def each_hash_utf8(&block)
    each_hash_orig do |row|
      row.each {|k, v| row[k] = encode(v) }
      yield(row)
    end
  end
  alias each_hash_orig each_hash
  alias each_hash each_hash_utf8
end

et pour environnement.rb on se retrouve avec:

Rails::Initializer.run do |config|
  ...
  config.after_initialize do 
    require 'lib/actionview_utf8'
    require 'lib/mysql_utf8'
  end
end

ouf, tous les tests passent...

Zend Framework avec lighthttpd

2009-12-29T17:02:00.005+01:00

Je vais travailler sur un projet en PHP avec Zend Framework. Venant du monde Rails, on s'habitue assez vite à lancer son serveur web dans un terminal, voir plusieurs en parallèle sans avoir à manipuler la configuration d'un Apache qui tourne sous un autre compte utilisateur.

En PHP je n'ai pas trouvé d'équivalent à Webrick ou Mongrel intégré à ZF, mais je m'en suis finalement sorti avec lighthttpd.

A la racine du projet ZF, créez un lighthttpd.conf dans lequel vous configurez entre autres:

le port 3000 (on ne change pas de vieilles habitudes :)
l'URL rewriting pour que toutes les requêtes passent par index.php (l'équivalent du .htaccess tel que créé par ZF)
l'accès à votre application via FastCGI

ce qui donne quelque chose comme suit:

server.document-root = env.PWD + "/public"
server.port = 3000

server.modules = (
  "mod_rewrite",
  "mod_fastcgi"
)


mimetype.assign = (
  ".html" => "text/html", 
  ".txt" => "text/plain",
  ".jpg" => "image/jpeg",
  ".png" => "image/png" 
)

url.rewrite-once = (
  ".*\?(.*)$" => "/index.php?$1",
  ".*\.(js|ico|gif|jpg|png|css)$" => "$0",
  "" => "/index.php"
)

static-file.exclude-extensions = ( ".php", ".pl", ".fcgi" )

server.indexfiles = ( "index.php" )

fastcgi.server = (
  ".php" =>
    ( "localhost" =>
      (
        "socket" => "/tmp/php-fastcgi.socket",
        "bin-path" => "/usr/bin/php-cgi"
      )
    )
)

Ensuite un petit script bash pour nous faciliter le lancement du serveur et l'initialisation de l'environnement ZF, par exemple start_zf.sh.

#!/bin/sh
export APPLICATION_ENV=development
lighttpd -f lighthttpd.conf -D

N'oubliez pas de rendre le script exécutable:

chmod +x start_zf.sh

puis lancez l'accès à votre projet ZF:

./start_zf.sh

Si tout va bien le site est accessible sur http://localhost:3000

SimpleWebDoc et yUML

2009-12-18T23:57:00.001+01:00

Je viens d'interfacer SimpleWebDoc et yUML pour générer les diagrammes d'héritage entre les classes d'un même package. Le tout à un clic de souris.

Le package Tests:

Le package Kernel:

SimpleWebDoc sur SqueakSource

2009-12-12T14:52:00.002+01:00

Suite à mon billet précédent, Pharo et documentation des packages, j'ai continué a explorer Pharo pour ressortir les méthodes des classes et les commentaires contenus en en-tête des méthodes.

J'ai mis le package SimpleWebDoc sur SqueakSource. Cela me donne l'occasion d'expliquer comment charger un package depuis Monticello. Tout d'abord lancez le Monticello Browser depuis le menu World.

Cela ouvre une fenêtre dans laquelle on voit les packages installés dans le panneau de gauche, les repository (dépôts) dans le panneau de droite. L'étape suivante est d'ajouter le repository où se trouve SimpleWebDoc dans la liste de ceux enregistrés dans Monticello. Cliquez sur le bouton +Repository et sélectionnez HTTP (Note: un repository Monticello est un simple répertoire local ou distant où se trouve les packages zippés, avec l'extension .mcz).

Saisissez ensuite l'emplacement du repository, ici: http://www.squeaksource.com/SimpleWebDoc

Le repository ajouté, sélectionnez-le et cliquez Open.

Une fenêtre s'ouvre listant tous les packages présents dans le repository (panneau de gauche) et la liste des versions disponibles (panneau de droite), la plus récente en tête. Sélectionnez la version la plus récente et cliquez sur Load pour charger le package SimpleWebDoc.

SWDocView est automatique enregistré comme application Seaside au chargement. Si vous regardez la méthode de classe initialize de SWDocView:

initialize
  self registerAsApplication: 'view-doc'

Une classe est un objet, et comme tout objet son instanciation appelle initialize. En chargeant le package SimpleWebDoc, on instancie la meta-classe SWDocView (elle même instance de MetaClass). SWDocView s'enregistre alors comme application nommée view-doc.

Vous pouvez donc ouvrir votre navigateur web préféré et aller à l'adresse:

http://localhost:8080/seaside/view-doc

Les méthodes de classe sont en italique et soulignées:

The Smalltalk way to learn Smalltalk

2009-12-10T10:18:00.001+01:00

Pour apprendre un nouveau langage, avant de me jeter sur le compilateur / interpréteur et tenter d'écrire un (mauvais) programme, j'achète un ou deux livres bien perçus pour m'imprégner de la philosophie et objectifs du langage. Je lis quelques programmes.

Pour Smalltalk je crois avoir commis une erreur et j'ai mis du temps à tout simplement "rentrer dedans", bien plus que tous les langages profondément objets étudiés auparavant (dont Ruby ).

I'm still amazed by how many people think they can grok Smalltalk by seeing syntax examples. Smalltalk isn't its syntax, it's its environment. Smalltalk is a living world of running objects, there are no files, no applications, just what's running. To understand Smalltalk, you have to either actually use it for a while, or have a seasoned Smalltalker demonstrate it to you. Reading sample code just won't cut it.
(Ramon Leon, Why Smalltalk)

C'est un vrai conseil ;)

Et je comprends maintenant ceci: Object oriented programming means something entirely different to a Smalltalker than to someone doing OO in another language.

Au passage, le blog de Ramon Leon OnSmalltalk est une vrai mine d'or, articles complets, bien écrits, profonds et les commentaires n'en valent pas moins.

Pharo et documentation des packages

2009-12-06T22:51:00.046+01:00

Voici quelques expérimentations faites alors que je voulais explorer les documentations contenues dans Pharo. Dans ce billet nous verrons comment ressortir les commentaires des classes d'un package donné. Puis je décrirai le codage d'une application Seaside minimaliste pour visualiser cette documentation depuis un navigateur Web.

1. Voyage au centre du package

Les classes sont regroupées dans des packages gérées par Monticello. On peut faire l'analogie avec les gems du monde Ruby ou les gestionnaires de paquets des distributions Linux.

Chaque package étant une instance de la classe MCPackage, on peut en sortir la liste. Ouvrez un Workspace et affichez le résultat du code suivant (via click-droit, print it)

MCPackage allInstances

Cela devrait vous retourner une longue liste de packages:

Comptons en le nombre en évaluant la taille du tableau retourné:

MCPackage allInstances size.

Sur mon image je trouve 155 packages.

Chaque package a un nom via l'accesseur name. On peut ainsi en sortir la liste:

MCPackage allInstances collect: [:p| p name]

En triant par ordre alphabétique:

(MCPackage allInstances collect: [:p| p name]) sort

Affichons le tout dans un Transcript. Ouvrez-le via le menu World > Tools > Transcript.

Puis évaluez le code suivant dans le Workspace:

|packageNames|
packageNames := MCPackage allInstances collect: [:p| p name].
packageNames sort do:[:name| Transcript show:name; cr]

Les objects PackageInfo référencent toutes les classes d'un package. Chaque objet MCPackage est associé à un objet PackageInfo.

Prenons par exemple le premier package et affichons toutes les classes qu'il contient via l'accesseur classes:

MCPackage allInstances first packageInfo classes

Pour extraire toutes les classes d'un package donné, une petite sélection fait l'affaire. Le code suivant renvoie toutes les classes du package System-Tools:

|systemTools|
systemTools := (MCPackage allInstances select: [:p| p name = 'System-Tools']) first.
systemTools packageInfo classes.

On peut accéder au commentaire de chaque classe via l'accesseur comment. Affichons le commentaire de la classe SpaceTally dans un Transcript:

Transcript show:SpaceTally comment

De là à afficher toutes les classes d'un package avec leurs commentaires, il n'y a qu'un pas:

|systemTools|
systemTools := (MCPackage allInstances select: [:p| p name = 'System-Tools']) first.
systemTools packageInfo classes do:[:c|
    Transcript show: '***',c name; cr.
    Transcript show: c comment; cr; cr]

2. Application Seaside pour consulter les commentaires

Rajoutons maintenant un peu de bling-bling à tout ça. Un Transcript c'est bien, une page web c'est plus rigolo.

Créons le package SimpleWebDoc qui contiendra une application Seaside minimaliste permettant de parcourir les commentaires des classes des packages.

Quelques précisions pour commencer. J'utilise ici l'image Pharo 1.0 RC1 09.11.04 avec Seaside et Pier, téléchargeable sur le site de Pharo à l'heure où j'écris ces lignes.

Le navigateur de classes utilisé par défaut est Browser (pour des raisons de performances et stabilité), or je vais utiliser le Package Browser. Pour changer le navigateur par défaut, ouvrez le navigateur de classe et dans le menu de la fenêtre sélectionnez Choose new default Browser.

Ici sélectionnez O2PackageBrowserAdaptator.

Lancez un nouveau navigateur de classe, vous devriez obtenir le Package Browser.

Ajoutons maintenant le package SimpleWebDoc: click droit, create package.

Nouveau clic droit sur le package et choisissez various > add to smart groups pour le rajouter dans l'onglet groups du Package Browser.

Créer application Seaside nécessite d'hériter WAComponent et de l'enregistrer comme application. Voici la déclaration de la classe SWDocView:

WAComponent subclass: #SWDocView
 instanceVariableNames: ''
 classVariableNames: ''
 poolDictionaries: ''
 category: 'SimpleWebDoc'

Pour afficher un composant, Seaside lui envoie le messager renderContentOn: en lui passant un objet WARenderCanvas sur lequel dessiner notre page web (en utilisant des brosses/brush). Nous allons ici construire un formulaire affichant tous les packages:

renderContentOn: html
 html form: [
  html select 
   list: (MCPackage allInstances collect: [:p| p name])
 ].

Améliorons la lisibilité du code en créant allPackageNames qui retourne les noms de tous les packages, dans l'ordre alphabétique:

allPackageNames 
 ^ (MCPackage allInstances collect: [:p| p name]) sort

et ajustons renderContentOn: en conséquence:

renderContentOn: html
 html form: [
  html select 
   list: self allPackageNames;
 ].

Testons ce que donne ce premier code. Déclarez le composant SWDocView comme application en évaluant ce qui suit dans un Workspace:

SWDocView registerAsApplication: 'simple-web-doc'

Pointez ensuite votre navigateur Web à l'adresse: http://localhost:8080/seaside/simple-web-doc

Ajoutons un bouton pour valider le formulaire:

renderContentOn: html
 html form: [
  html select 
   list: self allPackageNames;
  html submitButton with:'show'
 ].

Maintenant la partie intéressante: lorsqu'on valide le formulaire, on affiche la documentation du package. Pour cela nous stockons le nom sélectionné dans la variable d'instance selectedPackage en utilisant le callback de la brosse WASelectTag:

renderContentOn: html
 html form: [
  html select 
   list: self allPackageNames;
   callback: [:value| selectedPackage := value].
  html submitButton with:'show'
 ].

Si selectedPackage est définit, affichons la documentation:

renderContentOn: html
 html form: [
  html select 
   list: self allPackageNames;
   callback: [:value| selectedPackage := value].
  html submitButton with:'show'
 ].
 
 selectedPackage ifNotNil: [
   self renderPackage:selectedPackage On:html.
 ]

La méthode SWDocView>>renderPackage:On: qui reprends l'exemple précédent:

renderPackage:packageName On:html
  |package|
  package := (MCPackage allInstances select: [:p| p name = packageName]) first.
  package packageInfo classes do: [:c| 
    html heading level:2; with: c name.
      html break.
      html text: c comment.
      html horizontalRule.
  ]

et voici le résultat:

Amenons un peu de lisibilté en écrivant une méthode qui retourne toutes les classes d'un package:

classesOfPackageNamed: packageName
 |package|
 package := (MCPackage allInstances select: [:p| p name = packageName]) first.
 ^ package packageInfo classes

d'où une mise à jour de renderPackage:On:

renderPackage:packageName On:html
 (self classesOfPackageNamed:packageName) do: [:c| 
  html heading level:2; with: c name.
  html break.
  html text: c comment.
  html horizontalRule.
  ]

Bon nombre de choses sont à réaliser pour avoir une navigation correcte. Pour aller plus loin, consultez Dynamic Web Development with Seaside.

Minitube: youtube sans flash

2009-11-16T18:59:00.002+01:00

Attention, killer app. en vue: minitube permet de rechercher et visionner les vidéos de YouTube, le tout sans flash ! C'est rapide, simple et agréable à utiliser.

Minitube apporte l'originalité de lire les résultats de recherche les uns à la suite des autres, créant ainsi une sorte de programme TV sur demande.

Sous ArchLinux, j'ai eu besoin d'installer:

le backend xine pour phonon: sudo pacman -S phonon-xine
minitube via AUR: yaourt -S minitube

L'outil n'est pas le problème...

2009-11-03T22:22:00.002+01:00

(...ni forcément la solution)

Henrik Kniberg (gourou de l'agilité) utilise régulièrement cette image dans ses présentations:

Cela peut prêter à sourire, mais j'en ressort quelques règles:

évaluez les outils avant d'en choisir un, vérifiez qu'il correspond bien à vos besoins
connaissez intimement votre outil avant de l'utiliser en production: lisez des livres, retours d'expérience, internet est là pour vous aider
sachez dans quels cas ne pas l'utiliser

J'ai vu des équipes choisir Ruby et Rails après des déboires en PHP, pensant que Rails "c'est mieux". Aucun test unitaire, aucun apprentissage des conventions,... bref, retour au spaghetti code et déboires.

D'autres mettent en place un Subversion et pestent contre l'outil car ils se retrouvent constamment avec des conflits à chaque commit. Le fonctionnement par lock était mieux.

Ne parlons pas de tous les projets bancals en Visual Basic car VB, "c'est simple !".

Contrairement aux slogans, l'informatique, la programmation sont de plus en plus complexes. Il est de la responsabilité du développeur de se former.

Ruby, Python, Git, Scrum... sont des outils très puissants. "With great power, comes great responsibility": apprenez à maîtriser votre pouvoir !!

Groupe de lecture en entreprise

2009-10-21T22:46:00.006+02:00

J'apprends essentiellement par la lecture de (bons) livres: nouveaux langages, pratiques de développement, management... Or j'ai toujours éprouvé beaucoup de difficultés à faire lire ces mêmes livres à des collègues. Il semble de notoriété publique qu'un livre qui touche de près ou de loin à l'informatique est forcément difficile et ennuyeux à lire (pour être poli). Si de plus rédigé en anglais ...

Pour se donner le courage d'étudier un livre ensemble, d'apprendre et d'échanger autour de nouvelles connaissances, nous avons formé il y a deux mois un groupe de lecture dans mon entreprise. Nous avons commencé à trois personnes et maintenant nous sommes cinq, je croise les doigts pour que ça continue !

Voici la démarche que nous avons adopté:

1. Sélectionner un ouvrage:

Choisir un domaine dans lequel le groupe veut acquérir de nouvelles connaissances. Par exemple: Ruby, Python, Scrum, ...
Chercher et proposer une liste réduite de livres et/ou essais sur un thème donné. Se fier aux critiques des lecteurs pour avoir la certitude que le livre est bon. Attention aux mauvaises traductions: les budgets de traduction entre un Harry Potter et un livre d'informatique semblent très différents ;).
Acheter les livres (ou le PDF et imprimer). Chacun doit avoir son exemplaire.

2. Choisir une organisation:

A quelle heure se rencontre t'on ? Combien de fois par semaine ? Quels jours ? Quelle est la durée de la session ?
Dans notre cas, nous nous réunissons tous les Lundi et Jeudi à 12h, pendant 45 mn maximum.

Une personne doit être leader du groupe et s'assurer du respect de l'organisation (un Scrum Master du groupe de lecture en quelque sorte).

3. La préparation de la prochaine rencontre:

On choisit collectivement ce qui doit être lu pour la prochaine rencontre: les trois sections suivantes, le prochain chapitre.

Une personne doit être désignée (à tour de rôle) pour faire le résumé de la partie à lire.

4: La rencontre:

Tout le monde se retrouve autour d'une table. La personne en tâche de faire le résumé s'exécute. L'objectif est d'échanger, débattre et clarifier chacun des points abordés.

A la fin de la rencontre, retour au point 3 pour préparer la rencontre suivante.

Nous avons commencé cette pratique par la lecture de l'essai How to be a Programmer: A Short, Comprehensive, and Personal Summary de Robert L.Dead. Cela nous a permis de nous mettre en jambe avec un document court (quatre rencontres) et de valider notre fonctionnement.

Nous sommes ensuite passés à Plonger au cœur de Python (traduction de Dive Into Python de Mark Pilgrim) qui a l'avantage d'être ludique (et en français me diront certains).

Privoxy et NetworkManager

2009-10-16T08:46:00.005+02:00

Je suis passé à NetworkManager pour gérer les connexions réseaux sur mon portable et je trouve enfin cet outil fonctionnel et pratique. Seul petit soucis: privoxy (un proxy que j'utilise comme bloqueur de pubs, ce qui donne l'avantage de fonctionner quel que soit le navigateur web utilisé) perdait un peu les pédales à chaque fois que NetworkManager reconfigurait le réseau et j'étais obligé de le redémarrer.

Mais je viens de découvrir que NeworkManager peut exécuter des scripts à chaque reconfiguration réseau. Je dégaine mon éditeur et voici un script à placer dans /etc/NetworkManager/dispatcher.d qui démarre ou arrête privoxy selon que le réseau soit disponible ou non (attention, c'est pour ArchLinux):


#!/bin/bash

LOGGER="/usr/bin/logger -s -p user.notice -t NetworkManagerDispatcher"
PID=`pidof -o %PPID /usr/sbin/privoxy`

if [ -n $1 ] && [ $2 == "up" ]; then
    if [ ! -z "$PID" ];  then
        $LOGGER "Privoxy is running, restart"
        /etc/rc.d/privoxy restart
    else
        $LOGGER "Privoxy is stopped, start"
        /etc/rc.d/privoxy start
    fi
fi

if [ -n $1 ] && [ $2 == "down" ]; then
    if [ ! -z "$PID" ];  then
        $LOGGER "Privoxy is running, stop"
        /etc/rc.d/privoxy stop
    fi
fi

En prime vous aurez droit à quelques logs pour vérifier que ça fonctionne:


$ cat /var/log/messages.log |grep "NetworkManagerDispatcher"
...
Oct 15 18:42:09 magalo NetworkManagerDispatcher: Privoxy is stopped, start
Oct 15 18:42:11 magalo NetworkManagerDispatcher: Privoxy is running, stop
Oct 15 18:42:15 magalo NetworkManagerDispatcher: Privoxy is stopped, start
...

Embarquer Webkit

2009-10-02T08:58:00.001+02:00

Pour une application embarquée j'avais besoin vite fait d'un navigateur web sans fioritures et support CSS + Javascript. Finalement c'est tout simple avec Python et Webkit.

Avec pywebkitgtk :

import gtk 
import webkit 

view = webkit.WebView() 

sw = gtk.ScrolledWindow() 
sw.add(view) 

win = gtk.Window(gtk.WINDOW_TOPLEVEL) 
win.add(sw) 
win.show_all() 

view.open('http://acid3.acidtests.org/') 
gtk.main()

La mếme chose avec pyQt:

import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from PyQt4.QtWebKit import *

app = QApplication(sys.argv)
web = QWebView()

sa = QScrollArea()
sa.setWidget(web)
sa.show()

web.load(QUrl('http://acid3.acidtests.org/'))

sys.exit(app.exec_())

Ruby snippets pour Emacs

2009-09-17T22:21:00.001+02:00

Je viens de découvrir une excellente bibliothèque de gestion de snippets pour Emacs: yasnippet. Rapide à mettre en oeuvre, une bonne documentation et plein de snippets disponibles !!

Pour Ruby: http://github.com/Chrononaut/yasnippet-ruby-mode
Pour Rails: http://github.com/eschulte/yasnippets-rails/
Pour Shoulda: http://github.com/rwc9u/yasnippets-shoulda

Les lectures de l'été

2009-09-12T22:05:00.001+02:00

Je me suis fait une nouvelle petite cure pragmatique cet été. Les ouvrages du Pragmatic Bookshelf me plaisent toujours autant: bien construits, écriture fluide. Le soucis c'est que le livre finit on s'aperçoit qu'on a encore bien plus à apprendre qu'avant de commencer...

The Passionate Programmer: Creating a Remakable Career in Software Development de Chad Fowler adopte une structure similaire à Pragmatic Programmers: From Journeyman To Master. Chacune des 53 sections détaille une pratique, une attitude, une réflexion pour améliorer la prise en main de notre carrière de développeur et être reconnu par les différentes "tribus" (programmeurs, managers, clients, ...) avec lesquelles on se doit de communiquer. Le livre est très intéressant, convaincant, avec quelques bonnes anecdotes.
J'ai surtout aimé les parallèles avec l'apprentissage d'un instrument de musique et les habitudes, aspirations des musiciens. En musique on se doit de pratiquer régulièrement notre instrument et de travailler aux limites de ses possibilités pour progresser. L'amélioration de ses compétences de programmeur nécessite aussi d'adopter un rythme d'entraînement pour pratiquer sa technique.
Apprendre un instrument de musique différent de celui qu'on joue constitue un bon moyen de s'améliorer. Par exemple, un saxophoniste gagnera beaucoup à apprendre la basse ou la batterie, un bassiste le piano, ... Il est en effet plus rapide d'acquérir un jeu rythmique avec la basse ou la batterie, un jeu polyphonique avec le piano ou la guitare, ... De même, un développeur C peut apprendre Python, un développeur Java le Lisp, Erlang, ... pour découvrir des techniques plus facilement qu'avec le langage qu'il connaît. Si vous voulez comprendre la méta-programmation, utilisez Ruby. Pour l'objet prenez Smalltalk....

Pragmatic Version Control Using Git de Travis Swicegood fait partie du Pragmatic Starter Kit (contrôle de version, test unitaires, automatisation) qui constitue la boîte à outil de base du développeur pragmatique ;). Travis Swicegood présente les différents types de VCS puis détaille l'utilisation de Git jusqu'à des concepts avancés. Le livre est bien structuré, les exemples manquent parfois un peu de profondeur à mon goût. J'ai bien aimé la présentation de l'interface Subversion de Git (git svn) qui permet de synchroniser son dépôt Git local avec un dépôt Git central. Cela permet de profiter des apports de Git même si l'équipe utilise Subversion, ou bien faire une migration en douceur. Les fonctionnalités de séparer un commit en plusieurs et vice-versa constituent un bon complément aux lacunes de Subversion sur ce point (par exemple en période de mise au point où on corrige plusieurs bugs en même temps et qu'on veut faire un commit par correction de retour au bureau).

Enfin, Andy Hunt et Dave Thomas décrivent différentes techniques de test unitaires dans Pragmatic Unit Testing in C# with NUnit. Le livre détaille les cas auxquels nous sommes couramment confrontés dans l'écriture de tests unitaires (mocks, travailler avec des bases de codes non testées, le test d'interfaces graphiques) et liste exhaustivement les points à vérifier pour avoir des tests complets. Ceci dit, pour apprendre le développement piloté par les tests, je conseillerais plutôt l'ouvrage de Dave Astels "Test Driven Development: A Practical Guide". Le livre de Hunt et Thomas, certes de qualité, me paraît moins accessibles par les développeurs qui n'ont jamais écrit de tests.

Deux outils UML

2009-08-21T09:41:00.012+02:00

J'aime les outils UML qui permettent de créer des diagrammes rapidement. Malheureusement la plupart des outils offrent une interface très clickodrome avec des popups dans tous les sens qui alourdit leur utilisation.

Deux outils UML vraiment très sympas sortent du lot:

UMLet: écrit en Java, chaque élément graphique est affiché selon une entrée texte avec une syntaxe légère. Par exemple:


Movies
--
-moviesCollection:OrderedCollection
--
+add(aMovie)
+includes(aMovie):Boolean

affichera ceci:

yuml.me: c'est un service web qui génère un diagramme de classe à partir d'une description texte. On peut ensuite intégrer ce diagramme sur une page web. Par exemple:


[Movies|-moviesCollection:OrderedCollection|+add(aMovie);
+includes(aMovie):Boolean]+-*[Movie|+title],
[Movies]++-moviesCollection[OrderedCollection]

Génère ceci:

Pharo et tests unitaires (4): 1 Trait acheté, 4 tests offerts !!

2009-07-13T14:24:00.009+02:00

Dernière partie de la série:

utilisation des outils de test et debuggage
écriture et test d'une Collection: partie 1 , puis partie 2
utilisation des Traits dans les tests unitaires (ce billet)

Smalltalk ajoute à l'héritage un autre mécanisme de réutilisation de code, les Traits. Pour (sur-)simplifier, un Trait fournit un ensemble de méthodes définissant un comportement. Plusieurs classes peuvent utiliser un même Trait et une classe peut être composée de plusieurs Traits. Cela nous offre un moyen d'éviter des duplications de code en mutualisant des fonctions ou comportements génériques entre les classes.

On peut faire l'analogie avec les modules de Ruby (appelés aussi mixins). Par exemple, le module Observable implémente le design pattern du même nom. Si une classe inclut ce module, elle possède de fait les méthodes add_observer, notify_observers, ... Si cette même classe doit aussi être Singleton, il suffit de lui inclure le module en question.

Voici un exemple extrêmement scientifique:

require 'observer'
require 'singleton'

class Agathe
include Observable
# Agathe est unique
include Singleton

def reveille_toi
# ça peut mettre un peu de temps 
sleep 10*rand

changed true
notify_observers
end
end

class Laurent
# Laurent est unique aussi ;)
include Singleton

def initialize
Agathe.instance.add_observer self
  end

def update
puts "C'est pas trop tôt"
end

def reveille_agathe
Agathe.instance.reveille_toi
end
end

Laurent.instance.reveille_agathe

et le résultat:

$ ruby test_modules.rb
C'est pas trop tôt

Pour plus de détails sur les Traits de Smalltalk, vous pouvez consulter le document Traits: Composable Units of Behaviour(Nathanel Schärli, Stéphane Ducasse, Oscar Nierstrasz, Andrew P.Black).

La manière d'utiliser les Traits pour les tests unitaires dans Pharo m'a interpellé.

On écrit de nombreux tests unitaires de base qui se ressemblent, surtout lorsqu'on manipule des listes, des collections. Si on reprends notre exemple d'une classe qui représente une collection de films (Movies), on écrit à peu près les tests suivants:

pour une instance de Movies toute fraîche:

size retourne 0
isEmpty retourne true

j'ajoute un film (via Movies#add)

size retourne 1
isEmpty retourne false

j'ajoute trois films

size retourne 3

je retire un film

....

C'est sympa les premières fois mais la pratique devient vite répétitive. Heureusement, certains frameworks permettent de réduire ce genre de tests à une simple ligne de code (avec Shoulda dans le monde Rails par exemple).

Dans Pharo, des Traits dédiés à faciliter l'écriture des tests ont été écrits. On peut le voir en parcourant le package Collection-Tests. Les Traits sont par convention préfixés de la lettre T.

1. Test de la classe Movies avec le Trait TSizeTest

Créons notre champ d'expérimentation en ajoutant la classe MoviesWithTraitsTest:

Object subclass: #MoviesWithTraitsTest
instanceVariableNames: ''
classVariableNames: ''
poolDictionaries: ''
category: 'Movies'

Si vous avez bien suivi le premier billet sur les tests d'une Collection, nous testons la méthode Movies#size avec une collection vide, puis contenant un et plusieurs éléments. Et ça tombe bien, le Trait que TSizeTest existe.

Indiquons à notre classe de test d'utiliser ce Trait. Modifiez la définition de la classe comme suit:

Object subclass: #MoviesWithTraitsTest
uses: TSizeTest
instanceVariableNames: ''
classVariableNames: ''
poolDictionaries: ''
category: 'Movies'

et auto-magiquement, les méthodes du Trait sont ajoutées dans MovieWithTraitsTest.

Etudions la méthode MovieWithTraitsTest#test0TSizeTest:

test0TSizeTest
self shouldnt: [self empty] raise: Error.
self shouldnt: [self sizeCollection] raise: Error.
self assert: self empty isEmpty.
self deny: self sizeCollection isEmpty.

Les deux première lignes vérifient que les méthodes MovieWithTraitsTest#empty et MovieWithTraitsTest#sizeCollection ne lancent pas d'exception.

D'une part, les Traits ne peuvent définir de variables. D'autre part l'utilisateur du Trait a le devoir d'implémenter certaines méthodes pour le bon fonctionnement ce ce Trait.

Nous pouvons le vérifier en ouvrant MovieWithTraitsTest#sizeCollection:

sizeCollection
"Answers a collection not empty"
    ^ self explicitRequirement

Bon, allons examiner explicitRequirement pour en connaître les détails. Clic droit sur la méthode et sélectionnez implementors.

Cela nous amène à la définition de Object#explicitRequirement:

explicitRequirement
self error: 'Explicitly required method'

qui lance explicitement une jolie erreur.

Nous devons donc implémenter MovieWithTraitsTest#empty et MovieWithTraitsTest#sizeCollection. Commençons par la première en retournant une instance de Movies vide:

empty
^ Movies new

et une instance de Movies avec quelques éléments pour la suivante:

sizeCollection
"Answers a collection not empty"
    | movies |
movies := Movies new.
#('Amélie' 'Alien 4' 'Délicatessen') do: [:aTitle|
movies add: (Movie newWithTitle: aTitle)].
^ movies

et lançons les tests. Le debugger se manifeste:

MovieWithTraitsTest#test0TSizeTest vérifie le retour de la méthode Movies#isEmpty qui n'existe pas. Créons la méthode:

isEmpty
^ moviesCollection isEmpty

puis relançons les tests. C'est maintenant le test MovieWithTraitsTest#testSize qui s'arrête car Movies#do: aBlock n'est pas implémentée. Appuyons nous toujours sur moviesCollection:

do: aBlock
moviesCollection do: aBlock

et puis tout va beaucoup mieux.

2. Notre propre Trait

Allons plus loin en implémentant notre propre Trait de test. Pour reprendre la démarche du billet précédent, nous allons créer des tests vérifiant que Movies#includes: aMovie retourne true pour les instances de Movie qu'il contient, false dans le cas contraire.

Le test à false est plus simple à réaliser. Voici la méthode MoviesWithTraitsTest#testIncludesElementNotInReturnsFalse:

testIncludesElementNotInReturnsFalse
self deny: (self sizeCollection includes: self elementNotIn).

elementNotIn représente une instance qui n'est pas censée se trouver dans sizeCollection. Comme les Traits ne possèdent pas de variables d'instances, nous passons par une méthode:

elementNotIn
^ Movie newWithTitle: 'City Of Lost Children'.

Vérifiez le bon fonctionnement des tests, cela doit passer comme une lettre à la poste (quand il n'y a pas grève).

Passons au test opposé:

testIncludesElementInReturnsTrue
self assert: (self sizeCollection includes: self elementIn).

Cette fois-ci, MoviesWithTraitsTest#elementIn doit retourner une instance de Movie précédemment ajoutée à la collection retournée par sizeCollection. Nous devons passer par une variable d'instance.

elementIn
^ aVeryLongEngagement

et déclarez aVeryLongEngagement comme variable d'instance.

Initialisez ensuite cette variable dans la méthode setUp:

setUp
aVeryLongEngagement := Movie newWithTitle: 'A Very Long Engagement'

et nous pouvons ajouter l'instance dans MoviesWithTraitsTest#sizeCollection:

sizeCollection
"Answers a collection not empty"
| movies |
movies := Movies new.
#('Amélie' 'Alien 4' 'Délicatessen') do: [:aTitle|
movies add: (Movie newWithTitle: aTitle)].
movies add: aVeryLongEngagement.
^ movies

Ceci fait, nos tests passent.

3. Création du Trait

Nous allons maintenant extraire nos deux méthodes de test vers un nouveau Trait. Faites un clic droit sur la méthode testIncludesElementInReturnsTrue et sélectionnez move to trait...

Pharo demande le Trait dans lequel déplacer la méthode. Nous créons un nouveau Trait, cliquez *New Trait*:

puis choisissez lui un joli nom, ici TCollectionIncludesTest:

et votre nouveau Trait est né.

Si vous revenez à la définition de la classe MoviesWithTraitsTest, vous remarquerez qu'elle utilise notre Trait:

Celui-ci s'appuie sur deux méthodes: sizeCollection et elementIn:

testIncludesElementInReturnsTrue
self assert: (self sizeCollection includes: self elementIn).

elles sont destinées à être implémentées par les classes qui utilisent le Trait. Autant le rendre explicite. Rajoutons les méthodes suivantes à TCollectionIncludesTest:

sizeCollection
"Answers a collection not empty"
^ self explicitRequirement

elementIn
"Answers an instance included in self sizeCollection"
^ self explicitRequirement

Ajoutons enfin MoviesWithTraitsTest#testIncludesElementNotInReturnsFalse au Trait:

et complétons par la méthode elementNotIn:

elementNotIn
"Answers an instance not included in self sizeCollection"
^ self explicitRequirement

Voilà, le Trait peut être utilisé par d'autres classes.

4. Avantages et inconvénients.

L'utilisation des Traits apporte les avantages suivants:

la cohérence: un Trait définit un comportement, et les tests utilisant des Traits testeront ces mêmes comportements. Cela garantit que les mêmes noms de méthodes sur des objets de type différent aboutiront à un comportement similaire. On peut vérifier les conventions.
réutilisation: la mutualisation des méthodes de test évite les duplications de code pour tester des comportements similaires.

Ceci dit des effets de bord apparaissent. Si la granularité des Traits n'est pas assez fine, on se retrouve obligé à implémenter beaucoup de méthodes d'un coup. Par exemple, lorsque nous avons utilisé TSizeTest, nous avons dû implémenter Movies#do: et Movies#isEmpty, méthodes qui ne nous intéressaient pas forcément. Un Trait avec plus de tests nous aurait obligé à implémenter encore plus de méthodes. Cela peut casser la démarche de développement piloté par les tests.

Les Traits de test sont un atout, mais je pense important:

de bien étudier un Trait avant de l'utiliser
de garder des Traits avec un périmètre de test limité

Pharo et tests unitaires (3): les collections, seconde partie

2009-07-05T22:51:00.010+02:00

Episode 3, saison 1.

utilisation des outils de test et debuggage
écriture et test d'une Collection: partie 1 , puis partie 2 (ce billet)
utilisation des Traits dans les tests unitaires

Résumé de l'épisode précédent:

Inspector Thomas D. Derrick was facing Mister M., a supposed movies dealer. He had to find the truth. What did Mister M. do with the movies ?

- Where do you put the movies ? T.D.Derrick asked.
- I'm a Collection. I keep them.
- You're a Collection, aren't you ? So what's your size ?
- Well ... Zero now. I'm empty !!
- I'm sure you lie. Take this movie ... "Star Wars". Take it !
- OK OK, done.
- And tell me what's your size now ...
- One. You see, I have it.

These right answers did not disturbed T.D.Derrick.

- Play again with me. Add these movies. "Blade Runner" and ... this one, "Alien".
- Done.
- And now, your size ?
- Three. Can I go now ?

Mister M. seemed to be a real Collection. T.D.Derrick felt he was missing something. Then a subtil smile appeared on his face:

- Do you include Star Wars ?
- Err ... hard to tell. I don't understand.
- What ?
- I don't understand "include"
- Yep, I got you now !!
- Damned ...

Au dernier billet, j'ai décrit l'implémentation, pilotée par les tests, de la méthode Movies#size. La méthode retourne le nombre de films ajoutés via Movies#add.

Néanmoins, Movies utilise un compteur et ne passe pas par une Collection interne pour stocker les instances de Movie. Les tests nous ont permis de développer la solution la plus simple possible.

1. Test: Movies#includes: aMovie

Ajoutons un autre test pour notre collection: Movies#includes: aMovie pour une instance de Movie précédemment ajoutée retourne vrai, sinon faux.

testIncludesAnAddedMovieReturnsTrue
| movies starWars bladeRunner alien |
movies := Movies new.

starWars := Movie newWithTitle: 'Star Wars'.
bladeRunner := Movie newWithTitle: 'Blade Runner'.
alien := Movie newWithTitle: 'Alien'.

movies add: starWars; add: bladeRunner.        

self assert: (movies includes: starWars).
self assert: (movies includes: bladeRunner).
self deny:  (movies includes: alien).

Notez l'appel self deny : si la méthode TestCase#assert vérifie que l'expression en paramètre retourne true, TestCase#deny passe si l'expression testée retourne false.

Lancez le test. Le debugger s'arrête car Movies#includes:aMovie n'existe pas.

Comme vu au billet précédent, utilisez le bouton Create Method pour la déclarer.

Cette fois-ci, on doit vraiment passer par une collection interne.

includes: aMovie
^ moviesCollection includes: aMovie

Déclarons moviesCollection comme variable d'instance pour la rendre accessible aux autres méthodes de la classe Movies.

Comme toute variable d'instance, elle doit être initialisée. Au hasard, utilisons une instance d'OrderedCollection. Editez Movies#initialize:

initialize
super initialize.
size:=0.
moviesCollection:=OrderedCollection new

En relançant le test, le debugger indique que la première assertion ne passe pas. En utilisant la fonctions watch it sur (movies includes: starWars), le retour est en effet false.

Utilisons un autre outil de debuggage. Sélectionner movies, puis clic-droit, inspect it.

La fenêtre qui apparaît permet de visualiser l'état de l'instance Movies. En cliquant sur size, on voit que la méthode retourne 2. Cela semble logique, nous avons ajouté les instances "Star Wars" et "Blade Runner".

Regardons moviesCollection. Nous avons bien une instance d'OrderedCollection, mais vide (rien entre les parenthèses).

Pour s'en assurer, utilisons l'éditeur de la fenêtre pour demander la taille de moviesCollection. Tapez

moviesCollection size

puis utilisez la fonction inspect it.

On voit que size retourne bien 0 (une instance de la classe SmallInteger).

Les instances de Movie ne sont donc pas ajoutées à moviesCollection. Examinons la méthode Movies#add:

add: aMovie
size := size + 1

En effet ... modifions la méthode:

add: aMovie
size := size + 1.
moviesCollection add: aMovie

et maintenant le test passe !

2. Refactoring.

2.1 movies, starWars, bladeRunner et alien

Supprimons les duplications. Avant toute chose, vérifions que tous les tests de notre package Movies passent.

Les duplications se trouvent dans MoviesSizeTest. Les instances de Movie pour "Star Wars", "Blade Runner" et "Alien" sont créées dans les méthodes testWithOneMovieSizeReturnsOne, testWithThreeMoviesSizeReturnsThree et testIncludesAnAddedMovieReturnsTrue. De plus, chacune des méthode de test instancie Movies.

TestCase propose les méthodes setUp et tearDown pour ce genre de situation. TestCase#setUp est exécutée avant chaque test, et tearDown aprés chaque test. Lorsqu'on exécute tous les tests de MoviesSizeTest, l'appel des méthodes est le suivant (à l'ordre des tests près):

setUp
testIncludesAnAddedMovieReturnsTrue
tearDown
setUp
testNewInstanceSizeReturnsZero
tearDown
setUp
testWithOneMovieSizeReturnsOne
tearDown
setUp
testWithThreeMoviesSizeReturnsThree
tearDown

Nous allons mettre en commun la création des instances de Movie dans la méthode setUp. Définissez MoviesSizeTest#setUp comme suit:

setUp
movies := Movies new.
starWars := Movie newWithTitle: 'Star Wars'.
bladeRunner := Movie newWithTitle: 'Blade Runner'.
alien := Movie newWithTitle: 'Alien'.<br />

Les quatre variables sont des variables d'instances. Adaptez ensuite chaque méthode de MoviesSizeTest en vérifiant que les tests passent à chaque fois.

testNewInstanceSizeReturnsZero
self assert: movies size = 0

testWithOneMovieSizeReturnsOne
movies add: starWars
self assert: movies size = 1

testWithThreeMoviesSizeReturnsThree
movies add: starWars;
add: bladeRunner;
add: starWars.
self assert: movies size = 3

testIncludesAnAddedMovieReturnsTrue
movies add: starWars;
add: bladeRunner.
self assert: (movies includes: starWars).
self assert: (movies includes: bladeRunner).
self deny:  (movies includes: alien).

2.2 Renommer MoviesSizeTest

Le nom de la classe ne reflète plus assez la totalité des tests, car on vérifie les retours des méthodes Movies#size et Movies#includes. Le vrai objectif est de s'assurer que Movies#add ajoute bien les instances de Movie. Renommons la classe en MoviesAddMovieTest.

Pour ce faire, clic-droit sur la classe et sélectionnez rename.

Saisissez MoviesAddMovieTest comme nom de classe et validez.

2.3 Supprimer le comteur size de Movies

Regardons Movies#add de nouveau:

add: aMovie
size := size + 1.
moviesCollection add: aMovie

moviesCollection est une instance d'OrderedCollection.

OrderedCollection#size retourne le nombre d'instance stockées. On peut donc supprimer le compteur size qui fait doublon.

add: aMovie
moviesCollection add: aMovie

Relancez les tests:

Oups ... On s'aperçoit via le debugger que Movies#size retourne toujours 0.

L'erreur saute aux yeux en ouvrant Movies#size:

size
^ size

Corrigeons la méthode:

size
^ moviesCollection size

et les tests repassent !

Nettoyons au passage Movies#initialize pour supprimer l'initialisation de size:

initialize
super initialize.
moviesCollection:=OrderedCollection new

et nous pouvons finalement supprimer size des variables d'instances de Movies:

Object subclass: #Movies
instanceVariableNames: 'moviesCollection'
classVariableNames: ''
poolDictionaries: ''
category: 'Movies'

3. Pause publicité

Notre collection est minimale mais testée. Comme pour les billets précédents, nous écrivons d'abord le test puis nous nous laissons guider par les erreurs et le debugger pour implémenter le code fonctionnel.

Après chaque test, on modifie le code testé et de test pour l'améliorer.

La prochaine fois, nous retravaillerons MoviesAddMovieTest mais en utilisant les Traits, un mécanisme de réutilisation de code entre classes.

Pharo et tests unitaires (2): les collections, première partie

2009-07-01T20:56:00.019+02:00

En route pour le second billet de notre trilogie... qui devient au moins une quadrilogie (à vouloir trop en dire). Un petit point pour voir où nous en sommes dans la série:

utilisation des outils de test et debuggage
écriture et test d'une Collection: partie 1 (ce billet) puis partie 2
utilisation des Traits dans les tests unitaires

La programmation d'un logiciel implique généralement l'écriture de nombreuses collections. D'autant plus que les bonnes règles de design nous conseillent que chaque collection soit encapsulée dans sa propre classe. Nous manipulons ainsi des primitives de plus haut niveau.

Au passage, je conseille de lire l'essai "Object Calisthenics" de Jeff Bay paru dans "The ThoughtWorks Anthology". Jeff Bay y décrit neuf étapes aboutissant à un meilleur design, dont cette pratique sur les collections.

Si on écrit beaucoup de collections, cela implique de coder de nombreux tests de ces collections. Toutefois, on arrive assez facilement à implémenter ce genre de test et cela me semble donc un bon moyen de se familiariser avec le développement piloté par les tests.

Dans notre cas, nous avions précédemment créé la classe Movie. Nous allons maintenant écrire une collection Movies (notez le s) pour recenser des instances de Movie.

Nous aimerions connaître le nombre d'instances de Movie ajoutées à notre collection, via la méthode Movies#size. Voici les tests que nous pouvons écrire:

pour une instance de Movies toute fraîche (donc vide): size retourne 0
j'ajoute un film (via Movies#add): size retourne 1
j'ajoute trois films: size retourne 3

1. Test d'une instance Movies vide

Créons d'abord la classe MoviesSizeTest qui hérite TestCase:

TestCase subclass: #MoviesSizeTest
    instanceVariableNames: ''
    classVariableNames: ''
    poolDictionaries: ''
    category: 'Movies'

puis ajoutons notre premier test:

testNewInstanceSizeReturnsZero
    | movies |
    movies := Movies new.
    self assert: movies size = 0

Acceptez la méthode (Ctrl-s). Comme vu dans les billets précédents, Pharo va vous proposer de déclarer la variable movies, puis la classe Movies.

Lancez alors le test; le debugger s'arrête car nous n'avons pas redéfinit la méthode size.

Rajoutons la méthode Movies#size en appliquant un principe fondamental: "Do the simplest thing that could possibly work":

size
    ^ 0

relancez le test et savourez un instant ce sentiment de domination totale....

Pourquoi faire passer le test de manière aussi "stupide" ?

rappelez-vous que stupide est un compliment pour un programme ;) (Keep It Simple, Stupid) : le code reste le plus compréhensible possible.
on voit de manière flagrante que ce seul test est insuffisant.
on peut déjà archiver un travail testé.
on ressens la satisfaction d'un premier test qui passe, cela entretient la motivation.

De plus, ces premiers tests simples permettent de s'assurer de la présence de tous les éléments de base, ici la classe Movies et la méthode size (ce qui est un bon début).

2. Test d'une instance Movies contenant un film

Nous allons maintenant ajouter une instance Movie à notre collection et vérifier que size retourne 1. Voici le code de notre test:

testWithOneMovieSizeReturnsOne
    | movies starWars |
    movies := Movies new.
   
    starWars := Movie newWithTitle: 'Star Wars'.   
    movies add: starWars.
   
    self assert: movies size = 1

A l'exécution du test, le debugger s'arrête car la méthode Movies#add n'existe pas. Profitons en pour étudier quelques outils. Sur la droite du debugger, un bouton Create Method permet de créer directement la méthode manquante.

Pharo nous demande de choisir une catégorie pour notre méthode. Pour l'instant choisissez as yet unclassified, nous verrons par la suite qu'il existe une bonne fonction de paresseux pour classer les méthodes :). La méthode créée, le debugger reprends l'exécution et s'arrête dessus:

Nous voyons qu'un modèle de méthode a été enregistré, à nous de le modifier pour l'accorder à nos besoins. Vous pouvez saisir le "stupide" code suivant directement dans l'éditeur du debugger:

add: aMovie 
    size := 1

A l'acceptation, choisissez de déclarer size en variable d'instance.

Continuez le test (Proceed), le debugger s'arrête car l'assertion ne passe pas. On s'attends à ce que Movies#size retourne 1. Voyons ce que la méthode retourne actuellement. Sélectionnez movies size dans le code du debugger, clic-droit, choisissez watch it.

Une fenêtre s'ouvre et nous indique ce que retourne size.

En effet, nous n'avons pas modifié l'implémentation de Movies#size pour utiliser notre nouvelle variable d'instance. Editez la méthode:

size
    ^ size

et continuez le test.

Victoire !!

3. .... ou presque

Relançons tous les tests du package Movies pour vérifier que tout est bon. Sélectionnez le package dans la première colonne du Class Browser puis lancez les tests.

Enfer et damnation:

MoviesSizeTest#testNewInstanceSizeReturnsZero ne passe plus, Movies#size ne retourne pas 0. Comme vu précédemment, utilisez la fonction watch it pour afficher ce que retourne movies size.

Aie, nous n'aurions pas omis d'initialiser une certaine variable par hasard ?
Spécifions l'initialisation de la classe Movies pour mettre sa variable d'instance à 0. Dans la classe Movies, ajouter la méthode:

initialize
    super initialize.
    size:=0

puis relancez les tests.

C'est mieux.

4. Test d'une instance Movies avec trois films

Continuons en ajoutant trois films à notre instance de Movies et vérifions que Movies#size retourne 3:

testWithThreeMoviesSizeReturnsThree
   | movies starWars bladeRunner alien |
   movies := Movies new.
 
   starWars := Movie newWithTitle: 'Star Wars'.
   bladeRunner := Movie newWithTitle: 'Blade Runner'.
   alien := Movie newWithTitle: 'Alien'.        
 
   movies add: starWars; add: bladeRunner; add: alien.
   self assert: movies size = 3

Ce test ci ne devrait pas poser trop de problèmes. En le lançant, le debugger s'arrête car l'assertion ne passe pas. Après une petite vérification de movies size, nous voyons que size retourne 1. En effet, en ouvrant le code de Movies#add:

add: aMovie 
    size := 1

Modifiez le code comme suit:

add: aMovie 
    size := size + 1

et tout est sous contrôle.

5. Refactoring

Il est temps d'introduire un autre principe du développement piloté par les tests.

Les tests nous permettent de vérifier que nous n'avons pas cassé le fonctionnement de nos objets; nous pouvons alors prendre tout le loisir de jouer (si si, c'est un jeu) avec notre code pour l'améliorer.

Généralement, nous cherchons durant cette phase les duplications de code. Car nos maîtres l'ont dit: Don't Repeat Yourself !

Au passage, le sujet est bien traité dans Pragmatic Programmers: From Journeyman to Master par Dave Thomas et Andy Hunt.

Le refactoring concerne bien sûr le code testé, mais aussi notre code de test ! En pratique, lorsque les choses sont bien faites, le code fonctionnel teste notre code de test et vice-versa.

Une duplication se trouve dans la méthode MoviesSizeTest#testWithThreeMoviesSizeReturnsThree:

   starWars := Movie newWithTitle: 'Star Wars'.
   bladeRunner := Movie newWithTitle: 'Blade Runner'.
   alien := Movie newWithTitle: 'Alien'.

Améliorons le code en utilisant les jolies possibilités que nous procure Smalltalk:

testWithThreeMoviesSizeReturnsThree
   | movies |
    movies := Movies new.
        
    #('Star Wars' 'Blade Runner' 'Alien') do: [:title| 
        movies add: (Movie newWithTitle: title)].                

  self assert: movies size = 3

Pour être plus clair sur l'instanciation de Movie, on peut utiliser une variable locale au block:

    #('Star Wars' 'Blade Runner' 'Alien') do: [:title| 
        |aMovie|
        aMovie:= Movie newWithTitle: title.
        movies add: aMovie].

A chaque modification, assurez vous que les tests passent encore. Amusez-vous a explorer les possibilités de Smalltalk dans votre nouveau bac à sable, c'est fait pour ça. Si jamais vous avez besoin de revenir en arrière à une version qui fonctionnait, cliquez sur le bouton versions en haut à droite du Class Browser.

L'historique de la méthode apparaît et vous pouvez reprendre une version antérieure en cliquant sur revert.

6. Interlude

Si Movies#size fonctionne comme voulu, tests à l'appui, la fonction de stockage d'instances de Movie reste à réaliser.

Comme l'article deviens long, nous verrons ceci dans une seconde partie.

Nous avons vu les différentes étapes du TDD (Test Driven Development):

identifier une fonctionnalité
écrire le test
faire passer le test le plus rapidement possible
améliorer le code pour supprimer les duplications, simplifier, documenter, ...

Nous avons mis en œuvre quelques outils parmi la multitude que Pharo offre pour nous accompagner dans cette démarche.

Pour finir, les exemples sont fortement inspirés de l'ouvrage "Test Driven Development: A Practical Guide" de Dave Astels.

Pharo et tests unitaires: utilisation des outils

2009-06-26T22:17:00.021+02:00

Voici le premier billet d'une petite trilogie d'introduction sur l'écriture de tests unitaires dans Pharo. La série abordera les sujets suivants:

utilisation des outils de test et debuggage (ce billet)
écriture et test d'une Collection
utilisation des Traits dans les tests unitaires

Pour illustrer mes propos, je prendrai l'exemple extrêmement original de la manipulation d'une liste de films. Je veux créer des films, les ajouter à une liste et connaître le nombre total de films

Création du package Movies:

Pour commencer, créons le package Movies dans lequel nous mettrons toutes nos classes. Ouvrez le Class Browser, clic-droit dans la première colonne et sélectionnez create package. Saisissez Movies comme nom puis valider.

Le package Movies apparaît dans la liste classée par ordre alphabétique. Comme nous allons l'utiliser souvent, plaçons-le en tête de liste pour le retrouver facilement. Clic-droit sur le package et sélectionnez place package on top.

Notre premier test unitaire:

Passons ensuite à la classe Movie. Un film ayant un titre, nous allons vérifier qu'une instance de Movie possède un accesseur title qui retourne la chaîne passée à la construction de l'instance.

En développement piloté par les tests, on commence par écrire ... le test.

Déclarons une classe MovieTest qui hérite TestCase (classe de base pour les tests unitaires). Dans le panneau d'édition du Class Browser, saisissez le code suivant:

TestCase subclass: #MovieTest
    instanceVariableNames: ''
    classVariableNames: ''
    poolDictionaries: ''
    category: 'Movies'

Pour notre test, nous créons deux instances de la classe Movie en spécifiant leurs titres respectifs. Nous vérifions que les titres ont bien été assignés en utilisant la méthode assert de TestCase. Ajoutons la procédure testMovieHasATitle comme ceci:

testMovieHasATitle
    | starWars bladeRunner |
    starWars:= Movie newWithTitle: 'Star Wars'.
    bladeRunner:= Movie newWithTitle: 'Blade Runner'.

    self assert: starWars title = 'Star Wars'.
    self assert: bladeRunner title = 'Blade Runner'

Lors de la sauvegarde de la procédure, Pharo détecte que la classe Movie utilisée n'existe pas et nous propose de la déclarer. Ne nous en privons pas.

Pharo demande de saisir la définition de la classe et propose Object subclass: #Movie, ce qui conviens dans notre cas. De même pour la confirmation d'ajout de la classe dans le package Movie.

Lançons maintenant notre test unitaire. Clic droit sur la classe MovieTest et sélectionnez run the tests (si vous préférez les raccourcis clavier, tapez Ctl+t).

Pharo lance le test, détecte une erreur et nous propose d'ouvrir le debugger, ce que nous allons faire.

Implémentation de la classe Movie:

Le debugger nous présente la pile d'appel qui a conduit à l'erreur. Comme par hasard ;), la pile d'appel contient notre méthode MovieTest#testMovieHasATitle. En cliquant dessus, le debugger affiche le détail de la méthode et indique la ligne source de l'exception: on appelle la méthode inexistante newWithTitle de la classe Movie.

Retournons dans le Class Browser pour l'ajouter. Sélectionnez la classe Movie. Etant donné qu'on veut créer une méthode de classe, n'oubliez pas de cliquez sur le bouton class. La méthode doit créer une nouvelle instance de la classe Movie, lui assigner son titre et retourner l'instance.

newWithTitle: aString
    | movie |
    movie := Movie new.
    movie title: aString.
    ^ movie

Une fois la méthode acceptée, retournez dans le debugger et cliquez sur le bouton Proceed pour continuez l'exécution du test là où elle s'était arrêtée (si vous avez fermé le debugger, relancez le test).

Cette fois, le debugger va plus loin et s'arrête dans notre nouvelle méthode Movie#newWithTitle car l'instance de Movie ne connaît pas la méthode title:aString. Ajoutons-là dans le Class Browser (n'oubliez pas de cliquer sur le bouton instance):

title: aString
    title := aString

Lorsque vous acceptez la méthode, Pharo indique qu'il ne connaît pas la variable title. Comme cette variable est un attribut d'instance, sélectionnez declare instance. Si vous cliquez de nouveau sur la classe Movie pour afficher sa définition, vous apercevrez notre nouvelle variable d'instance.

Object subclass: #Movie
    instanceVariableNames: 'title'
    classVariableNames: ''
    poolDictionaries: ''
    category: 'Movies'

Continuons l'exécution en cliquant sur Proceed. Nous venons de créer la méthode Movie#title: pour assigner le titre, il nous manque la méthode Movie#title pour le lire. Ajoutez là:

title
    ^ title

Cette fois-ci, victoire !!

Vous remarquerez le voyant vert indiquant que la totalité des tests de notre classe sont passés.

Notez aussi que l'implémentation de la classe Movie a été pilotée par le test: c'est en suivant les erreurs indiquées par le debugger que nous avons écrit le code réel. C'est une des raisons pour considérer le code de test plus important que le code réel.

"OH: the trick is to write unit tests while you're sober, then write the code while you're drunk.", auteur dont j'ai oublié de noter le nom.

Dans le prochain billet, nous écrirons la classe Movies qui recense les films et les tests associés.

Jouons avec Pharo et Seaside

2009-06-16T23:19:00.020+02:00

J'ai assisté il y a quelque temps a une conférence de Stéphane Ducasse à l'Institut de Management d'Annecy. Co-créateur de projet Pharo et développeur actif de la communauté Smalltalk, Stéphane nous a présenté différents outils dont Seaside, un framework dédié à l'écriture d'applications Web (en insistant sur le terme application).

Pharo est une implémentation Open Source du langage Smalltalk, qui se veut moderne, agile et cohérente. Pharo est né comme un fork de Squeak, puis a évolué en nettoyant l'implémentation des parties obsolètes, bancales ou instables, en simplifiant l'intéraction avec l'environnement de développement et en intégrant des outils de développement efficaces. De plus, chose essentielle, ils ont créé un joli logo.

La première version stable 1.0 ne devrait plus trop se faire attendre (vers l'automne ?)

J'avais déjà assisté a une présentation de Seaside aux RMLL à Mont-de-Marsan. Mais je voulais d'abord découvrir Smalltalk et du coup je suis passé à côté d'un des principaux fonctionnements novateurs qu'apporte Seaside au développements Web.

Stéphane a parcouru un diaporama de Lukas Renggli "The Heretic Web Framework" disponible ici.

Prenons un exemple simple d'application "classique": nous voulons demander deux nombres et afficher le résultat dans une console. En python nous pourrions coder comme suit:

value1 = input("Premier nombre: ")
value2 = input("Second nombre: ")
print(value1+value2)

Tant que l'utilisateur n'a pas saisi de nombre, le programme reste en attente sur la fonction input Nous utilisons le retour de la fonction pour stocker les deux valeurs.

Imaginons la même application en environnement Web. Le programme de calcul fonctionne côté serveur et l'utilisateur se sert de son navigateur Web pour saisir les valeurs. La plupart des systèmes actuels nous propose de créer une vue ou template pour définir l'interface utilisateur, un contrôlleur pour exécuter les requêtes client et renvoyer le résultat. Nous devons généralement implémenter un graphe d'état et manipuler les sessions pour savoir si nous en sommes à la demande de la première ou seconde valeur.

Seaside permet de programmer de la même manière qu'une application classique. L'équivalent Seaside/Smalltalk du code python précèdent est:

| value1 value2 |
value1 := self request: ‘Premier nombre’.
value2 := self request: ‘Second nombre’.
self inform: value1 asNumber + value2 asNumber.

On n'est pas dépaysé....

Maintenant un peu de concret. Téléchargez la machine virtuelle Pharo et l'image intégrant Seaside sur le site du projet.

Sous Linux, on doit malheureusement bricoler un peu. Décompressez la machine virtuelle puis activez le bit d'exécution du binaire squeak:

unzip pharo-vm-0.15.1b-linux.zip
chmod +x pharo-vm-0.15.1b-linux/squeak

On peut ensuite décompresser l'image et la lancer:

unzip pharo0.1-10324web09.06.1.zip
pharo-vm-0.15.1b-linux/squeak pharo0.1-10324web09.06.1/pharo0.1-10324web09.06.1.image

L'image ouverte, Seaside tourne sur le port 8080. Vous pouvez le vérifier en pointant votre navigateur Web à l'adresse http://localhost:8080/seaside.

Dans Seaside, les points d'entrée de nos applications doivent être définis. Nous allons créer une nouvelle classe de type WATask, un "contrôlleur" Seaside, et l'assigner à une URL.

Les classes peuvent être définies un utilisant le Class Browser, via le menu World ouvert par un clic sur le bureau Pharo. Dans la première colonne, sélectionnez Unpackaged (tout en bas) pour créer une nouvelle classe sans la placer dans un package particulier. Dans la zone de saisie du bas, saisissez le code suivant pour déclarer la classe Additionneur qui hérite WATask.

WATask subclass: #Additionneur
    instanceVariableNames: ''
    classVariableNames: ''
    poolDictionaries: ''
    category: 'Unpackaged'

Ouvrez le menu contextuel de la zone de saisie via un clic droit et sélectionnez accept pour enregistrer la classe.

Ceci fait, notre classe doit se déclarer comme application accessible directement via un point d'entrée. Pour trouver ce type d'application, Seaside parcours toutes les classes héritant WAComponent (qu'hérite WATask et donc Additionneur) et sélectionne celles dont le retour de la méthode canBeRoot est true.

(Mise à jour: d'autres moyens sont disponibles, voir le commentaire de Damien)

Pour ajouter une méthode de classe, sélectionnez la classe Additionneur dans la seconde colonne puis cliquez sur le bouton class pour visualiser les méthodes de classe. Sélectionnez la catégorie -- all -- dans la troisième colonne, puis entrez le code suivant dans la zone de saisie:

canBeRoot 
    ^true

Enregistrez alors la méthode via la commande accept du menu contextuel.

Vérifions que notre Additionneur peut être accessible depuis l'interface de configuration de Seaside. Ouvrez la page en question depuis votre navigateur Web à l'adresse suivante: http://localhost:8080/seaside/config. Le compte par défaut est admin / seaside.

Dans la section Settings, Add an entry point, saisissez le nom de votre nouveau point d'entrée, par exemple additionneur. Je précise que ce nom est indépendant du nom de la classe (au cas où vous seriez un développeur Rails ;) ). Sélectionnez Application comme Type puis cliquez sur Add.

Vous entrez alors dans la page de configuration de l'application. Sous la section Configuration/General, modifiez le paramètre Root Component pour sélectionnez la classe Additionneur dans la liste déroulante. Cliquez enfin sur Save en bas de la page.

En cliquant sur Close vous revenez à la page principale de configuration de Seaside.

Vous devriez voir apparaître le point d'entrée additionneur associé à la classe Additionneur dans la liste /seaside/.

Si vous cliquez sur le lien maintenant, vous aurez une erreur car nous n'avons pas encore implémenté le fonctionnement de notre application, ce que nous allons écrire de suite.

Retournez dans Pharo. Seaside cherche à évaluer la méthode go d'une instance de notre classe Additionneur. Pour l'ajouter, sélectionnez d'abord les méthodes d'instance en cliquant sur le bouton instance en dessous de la seconde colonne du Class Browser. Cliquez ensuite sur la catégorie -- all -- et saisissez le code présenté précédemment:

| value1 value2 |
value1 := self request: ‘Premier nombre’.
value2 := self request: ‘Second nombre’.
self inform: value1 asNumber + value2 asNumber.

puis enregistrez-la (clic droit, accept).

Maintenant pointez votre navigateur sur l'application à l'adresse suivante: http://localhost:8080/seaside/additionneur et goûtez à la joie d'avoir une application qui fonctionne du premier coup.

Si ce n'est pas le cas, je décline toute responsabilité quant aux dommages irréversibles que pourraient causer mes indications sur la santé de votre ordinateur...

Pages du matin

2009-06-05T22:41:00.009+02:00

Dans "Pragmatic Thinking and Learning", Andy Hunt expose plusieurs techniques pour simuler notre prodution d'idées et ne pas les perdre. L'écriture revets une impordance primordiale, et A.Hunt nous conseille de garder constamment à portée de main de quoi écrire - que ce soit un PDA, un carnet ou tout autre support. On retrouve des approches similaires dans "Mind Performance Hacks" de Ron Hale-Hevans (tip 13: Catch Your Ideas)

Pour arriver à imprimer notre créativité sur papier, A.Hunt nous présente la technique des Morning Pages. Cette technique s'appuie sur le constat que notre cerveau droit (le plus créatif, voir mon billet précédent "Pomodoro technique et cerveau droit") bouillone d'activité la nuit. Nous rêvons, pensons et génêrons des hypothèses, situations improbables, du moins pour notre cerveau gauche. Lorsque nous nous levons, notre cerveau droit laisse peu à peu le cerveau gauche prendre la majorité de nos pensées.

Les Morning Pages sont décrites comme un moyen de capter cette effervescence de notre cerveau droit. Le principe s'avère simple. Tous les matins, la première chose à effectuer (avant même de préparer le café, réveiller les enfants, ...) est de s'asseoir à table, prendre un stylo et écrire trois pages. On ne doit pas réfléchir à ce qu'on écrit, ne pas tenter de diriger ses idées ou essayer de formuler ses phrases. Ecrivez vos pensées telles qu'elles arrivent, même si cela semble stupide, illisible, ...

Vous verrez que progressivement se dessinent des choses auxquelles vous n'avez jamais pensé, relatives au travail ou à votre quotidien. Des idées de développement de logiciels, plans de production, organisation d'un week-end en famille, ...

De plus, je trouve que cette manière d'écrire très agréable, rapide et nous donne l'impression d'avoir accomplit quelque chose dès le matin. Si vous voulez avoir un fou rire en soirée, il suffit parfois de relire vos Morning Pages de quelques jours passés, on s'étonne soi-même ;)

Ceci dit, la régularité m'apparaît plus importante que la quantité. On peut faire une analogie avec la musique; il est préférable de travailler son instrument 20 mn tous les jours que 5 heures seulement le dimanche. J'ai trouvé assez difficile d'écrire trois pages régulièrement tout de suite. J'ai finalement commencé par faire une page, puis ma rapidité d'écriture s'améliorant, la quantité progresse naturellement.

Ruby et bases MS Access: Olé !!

2009-06-01T22:15:00.009+02:00

J'ai eu besoin d'automatiser quelques manipulations de bases de données MS-Access. Une possibilité en Ruby est d'utiliser les ActiveX ADO grâce au module win32ole. Je vais montrer l'utilisation de ce module avant d'attaquer MS Access

Voici un exemple de pilotage d'Internet Explorer via OLE. Commençons par lancer irb et importer le module win32ole:

C:\sandbox>irb
irb(main):001:0> require "win32ole"
=> true

Créons une nouvelle instance d'Internet Explorer:

ie = WIN32OLE.new("InternetExplorer.Application")

Pour connaître la liste des attributs d'un objet OLE, on utilise WIN32OLE::ole_get_methods:

irb(main):002:0> ie.Application.ole_get_methods
=> [Application, Parent, Container, Document, TopLevelContainer, Type, Left, Top, 
Width, Height, LocationName, LocationURL, Busy, Name, HWND, FullName, Path, 
Visible, StatusBar, StatusText, ToolBar, MenuBar, FullScreen, ReadyState, Offline,
Silent, RegisterAsBrowser, RegisterAsDropTarget, TheaterMode, AddressBar, 
Resizable]

Affichons la fenêtre et allons sur un site au hasard :)

irb(main):003:0> ie.Visible=true
=> true
irb(main):004:0> ie.Navigate("http://magaloma.blogspot.com")
=> nil

Fini de jouer:

irb(main):005:0> ie.Quit
=> nil

Pour se connecter à une base MS Access, nous utilisons l'ActiveX ADODB.Connection. Par exemple:

dbcon = WIN32OLE.new("ADODB.Connection")
dbcon.Open("Provider=Microsoft.ACE.OLEDB.12.0;Data Source=bibliotheque.mdb")

ADOX.Catalog perment d'inspecter la base:

catalog = WIN32OLE.new('ADOX.Catalog')
catalog.ActiveConnection = dbcon
catalog.Tables.count
=> 11
catalog.Tables.Item(0).Name
=> "auteurs"

On peut ensuite récupérer quelques enregistrements avec ADODB.Recordset:

recordset = WIN32OLE.new('ADODB.Recordset')
recordset.Open("SELECT * FROM livres", dbcon)

Pour ressortir les noms des champs:

recordset.Fields.each {|f| puts f.Name}

Ce qui nous retourne:

id
titre
autheur_id

GetRows permet de récupérer les données:

recordset.GetRows.transpose
=> [[1, "Pragmatic Thinking And Learning", 1], [2, "Art Of Unix Programming", 2]
, [3, "Practices Of An Agile Developper", 1]]

Voilà. Merci au site Ruby On Windows pour m'avoir bien aidé.

Fin d'une journée Pomodoresque

2009-05-26T23:11:00.002+02:00

La journée de travail touche à sa fin, il ne me reste pas assez de temps pour commencer un nouveau Pomodoro. Il est temps d'analyser puis de synthétiser les activités du jour.

Dans un premier temps, je reporte sur la feuille d'Enregistrements les activités pour lesquelles j'ai alloué des Pomodori. Je note la date du jour dans une première colonne.

En face de chaque activité, j'indique ensuite l'écart entre l'estimation du nombre de Pomodori nécessaires à l'accomplissement de l'activité de ceux réellement utilisés. Par exemple en début de journée j'ai estimé la tâche "Logiciel XXX: en-tête, afficher la date + heure du serveur" à 2 Pomodori et j'en ai finalement utilisé 3. J'obtiens donc un écart de -1.

Je note ensuite le nombre total de Pomodori réalisés ainsi que le nombre total d'interruptions.

Je prends alors mes stabilos de couleur et je surligne ce qui me paraît important (gros écarts, activité qui s'est mal déroulée, ...). Je cherche à décrire les causes des écarts et interruptions ainsi que les solutions possibles à l'amélioration de mon process.

Finalement, je retourne ma feuille d'Activités du Jour et je dessine un Mind Map pour faire ressortir les points forts de la journée que je veux retenir.

Ce que j'aime dans ces pratiques est que d'une part on se sent construire une expérience, de l'autre on arrive trés vite à se remettre dans le bain le lendemain ou après le week-end. En début de journée je relis le Mind Map de la veille et la feuille d'Enregistrements avant de planifier la journée. Le Lundi matin je relis la totalité des Mind Maps de la semaine précédente.

Un Pomodo est indivisible

2009-05-15T22:32:00.002+02:00

Un Pomodoro est indivisible, il n'existe pas de demi ou quart de Pomodoro. Deux évènements peuvent nous inciter à diviser un Pomodoro et nous faire basculer du côté obscur:

nous n'arrivons pas à gérer une interruption (question d'un collègue, coup de téléphone, ...) en plein Pomodoro.
nous terminons une activité avant la fin du Pomodoro.

Voyons ce que la règle d'indivisibilité nous apporte dans chaque cas.

1. L'interruption

Si nous interrompons un Pomodoro, on doit le considérer annulé. Pas de croix sur sa feuille du jour, pas de récompense. Cela peut s'avérer trés frustrant lorsqu'il ne reste plus que deux minutes au Pomodoro. Ou bien quand cinq fois de suite nous commençons notre Pomodoro et à chaque fois quelqu'un a besoin de nous au bout d'une minute.
Cette frustration va nous pousser à trouver des solutions pour ne pas être interrompu et augmenter le nombre de Pomodori réalisés par jour. En voici quelques unes:

le téléphone sonne: laissez le répondeur répondre à votre place. Vous pouvez toujours rappeler à la fin de votre Pomodoro.
un nouveau mail arrive: le mieux est de fermer sa messagerie.
un collègue viens vous voir: demandez si c'est vraiment urgent et s'il est possible de voir ça dans quelques minutes, le temps de finir la tâche en cours.

Dans chaque cas, marquez sur votre feuille ce que vous devrez faire une fois le Pomodoro terminé pour ne pas l'oublier.

2. L'activité terminée

Vous venez de terminer ce que vous étiez en train de faire (un devis, développement, ...) mais il reste encore dix minutes au Pomodoro. A ce moment là il faut rester sur la même activité et profiter de ce temps pour passer l'activité en revue:
Pour un développement, relisez le code écrit. Vérifiez s'il est compréhensible, si des implémentations alternatives sont possibles (voire souhaitables), si les tests unitaires couvrent tous les cas. Pour un devis, vérifier les temps, coûts, comparer avec d'autres devis. Demandez-vous si vous auriez pu réaliser votre tâche en moins de temps, comment, notez-le.
Le Pomodoro nous oblige à vérifier ce que nous venons de faire. On évite d'expédier un peu trop vite notre travail et cela nous donne confiance dans nos réalisations. Dans les périodes où la pression se fait ressentir, bien des erreurs peuvent ainsi être évitées.

Le Pomodoro au quotidien

2009-05-14T22:23:00.002+02:00

Documents:

A l'instar de Scrum avec son Backlog, Pomodo necessite tout d'abord un Inventaire des Activités. On peut prendre une simple feuille A4 sur laquelle on écrit une activité / tâche par ligne. Lorsqu'une acitvité se termine, on la raye. Si la feuille est pleine (environ 25 activités) et qu'on a besoin d'en rajouter, on prends une nouvelle feuille vierge. On y reporte les activités toujours d'actualité ainsi que les nouvelles.
Une nouvelle feuille des Activités du jour est créée quotidiennement. On peut comparer cette feuille au Sprint Backlog de Scrum. On sélectionne quelques activités de l'Inventaire des Activités pour les porter sur cette feuille. En face de chaque activité on écrit notre estimation de Pomodori pour cette tâche.
La feuille d'Enregistrements est mise à jour chaque fin de journée. Elle contient la synthése de la journée, une sorte de Sprint Retrospective. On y indique tout ce qui peut nous permettre d'améliorer le processus.

Déroulement:
La journée se décompose en 5 étapes quotidiennes [1]:

Planification: au début de la journée, on sélectionne les activités les plus importantes de l'Inventairedes Activités que l'on estime réalisables dans la journée. On écrit ces activités sur une nouvelle feuille d'Activités du Jour.
Suivi: à la fin de chaque Pomoro (25 minutes), on ajoute un X en face de l'activité dans les Activités du Jour (si il n'a pas été interrompu). On écrit aussi les informations relative à l'activité qui nous semblent importantes (liste des interruptions et leur type).
Enregistrement: à la fin de ma journée, je reporte la liste des Pomodori terminés et mes observations associées sur la feuille des Enregistrements.
Traitement:on analyse les données des la feuille des Enregistrements et on en extrait les informations. On va par exemple calculer l'écart entre le nombre de Pomodori estimés et réalisés par activité, la moyenne de Pomodori effectués par jour, le nombre d'interruptions rencontrées, leur nature.
Retrospective: on analyse les enregistrements dans l'objectif de nous améliorer. Quelles ont été mes erreurs d'estimation ? Comment pourrais-je éviter ces interruptions ?

La journée commence donc par la Planification. Se succèdent ensuite plusieurs phases de Suivi, après chaque Pomodoro. La journée se termine par l'Enregistrement, le Traitement et la Retrospective.
[1]: Staffan Nöteberg - "Pomodoro Technique Illustrated" DRAFT 27/04/2009

Pomodoro technique et cerveau droit

2009-05-09T22:33:00.010+02:00

La "Pomodoro technique" permet d'optimiser sa gestion du temps. Elle se présente comme un moyen d'éliminer son anxiété (de manque) du temps, d'améliorer son attention et sa concentration.
Pomodoro signifie tomate en italien et fait référence au minuteur de cuisine de l'auteur Francesco Cirillo en forme de tomate.
La technique s'apparente aux méthodes agiles, itératives. Là où les méthodes agiles s'attachent beaucoup à l'équipe, Pomodoro s'intéresse plus à l'individu. La technique peut néanmoins s'utiliser en groupe. Henrik Kniberg décrit le processus comme un Scrum individuel basé sur des itérations de 25 mn, qui en garde la plupart des avantages (cf le billet sur son blog).
Le Pomodoro nous contraint (dans le bon sens du terme) à exercer la même activité sans interruptions pendant une tranche de temps courte et de durée fixe. L'objectif est de maximiser sa concentration sur ces 25 minutes et nous apprendre à gérer rapidement les interruptions (un mail qui arrive, coup de téléphone, question d'un collègue) et à les reporter sur un Pomodoro suivant.
Le livre téléchargeable "The Pomodoro Technique" en décrit les règles:

Un Pomodoro (unité de mesure) dure 25 minutes, plus 5 minutes de pause.
On prends une pause de 15 à 30 minutes tous les 4 Pomodori.
Un Pomodoro est indivisible. Il n'existe pas de demi ou quart de Pomodoro.
Un Pomodoro commencé doit obligatoirement se terminer:

Si un Pomodoro est stoppé car on n'a pas su gérer la perturbation / interruption, on doit le considérer comme nul.
Si une activité se termine avant la fin d'un Pomodoro, on ne change pas d'activité et on utilise le temps restant pour passer en revue cette activité.

Protégez le Pomodoro. Informez efficacement, négociez rapidement la planification de l'interruption, rappelez la personne qui vous a interrompu au moment convenu.
Si vous estimez une tâche à plus de 5-7 Pomodori, divisez la. Les tâches complexes doivent être décomposées en plusieurs tâches.
Si vous estimez une tâche à moins d'un Pomodoro, combinez la avec d'autres tâches simples.
Les résultats sont enregistrés après chaque Pomodoro.
Le Pomodoro suivant se déroulera mieux.

A noter que Staffan Nöteberg prépare un livre sur le sujet, "Pomodoro Technique Illustrated", et propose de télécharger les ébauches sur http://www.pomodoro-book.com/.

Quel rapport avec le cerveau droit ? L'obligation des pauses de 5 et 15-30 minutes m'a intéressé.
Dans "Pragmatic Thinking & Learning", Andy Hunt détaille le fonctionnement du cerveau et explique les avantages qu'on peut tirer quotidiennement de cette connaissance, comment nous pouvons améliorer l'utilisation de notre matière grise. La distinction cerveau droit et gauche symbolise deux fonctionnements identifiés. En simplifiant à l'extrême:

le cerveau gauche fonctionne par logique (si dans X je mets Y alors j'obtiens Z), s'occupe du langage, analyse les détails. C'est la voix qui nous parle.
le cerveau droit fonctionne par synthèse, avec une vision globale. Il nous fait rêver et nous apporte de nouvelles idées. C'est un cerveau créatif, riche.

Andy Hunt nomme ces deux manières d'utiliser notre cerveau L-Mode (pour left et linéaire) et R-Mode (pour right et riche). Si quelqu'un a un moyen mémotechnique en français...
Nous ne pouvons pas utiliser nos deux cerveaux à la fois. Lorsqu'on programme, tape sur le clavier, on utilise notre cerveau gauche, linéaire, analytique. Lorsqu'on bloque sur notre programme, on s'éloigne du clavier, regarde ailleurs, arrêtons de nous parler. Nous laissons travailler notre cerveau droit pour qu'il nous donne une solution.
Malheureusement, l'éducation et l'entreprise nous ont forgés à sur-utiliser notre cerveau gauche au détriment du droit. On ne nous paye pas à méditer, rêver, dessiner ou jouer de la musique. Ce sont pourtant ces activités qui nous permettent de développer nos idées et nos manières de penser. Ceci dit, des entreprises prennent conscience de ce phénomène et intègrent des activités sportives, artistiques ou de relaxation au quotidien.
Mais revenons au Pomodoro. Une itération dure 25 minutes puis nous prenons 5 minutes de pause, ou 15-20 minutes tous les 4 Pomodori. Pendant ces pauses, il ne faut pas penser à l'activité que nous venons d'exercer. Rêvez, allez marcher dans un endroit tranquille, dessinez sur une feuille... activez votre cerveau droit ! C'est à ce moment là que les idées arrivent et peut-être une meilleure solution aux problêmes que nous tentions de résoudre. Dès qu'une idée apparaît, notez-là pour ne pas la perdre. Combien de fois avons nous eu des idées géniales sous la douche que nous avons perdu cinq minutes après...

Le pair-programming, deux développeurs pour un ordinateur, permet d'utiliser les deux modes de fonctionnement en même temps. La personne qui tape est en mode analytique (cerveau gauche) et celui qui pilote en mode synthétique, il garde le recul sur le développement. Il me reste à essayer la combinaison pair-programming + Pomodoro et voir si les deux pratiques se combinent bien...

Vous êtes ce que vous faites

2009-05-02T11:43:00.007+02:00

Un nouvel article sur le blog d'Andy Hunt concernant "Pragmatic thinking & Learning" arrive comme par hasard.

Pour ceux que l'anglais rebute:

On ne peut devenir expert sans expérience.
Devenir expert dans un domaine nécessite approximativement 10 ans, 10 000 heures de pratique.
Seule une pratique réfléchie, avec un objectif d'amélioration fait la différence. Suivre le mouvement ne suffit pas. (Ça me rappelle un article sur la musique précisant que lorsque un musicien travaille vraiment son instrument, cela sonne très mal car il tente de jouer au delà de ses limites).
La pratique n'amène pas la perfection, mais amène la permanence: le cerveau se modifie en fonction de ce que l'on fait.

On ne deviendra (peut-être) pas ce qu'on aspire à être. On deviens ce que l'on fait.

Modèle Dreyfus

2009-05-01T15:15:00.007+02:00

Je viens de recevoir "Pragmatic Thinking and Learning" de Andy Hunt (co-auteur du célèbre "The Pragmatic Programmer: From Journeyman to Master"). Le livre s'annonce passionnant.

Le second chapitre présente le modèle Dreyfus d'acquisition de compétences. Cette théorie dit que le passage de novice à expert d'un domaine donné passe par cinq étapes.

étape 1: Novice

l'activité change sa manière de penser car il acquiert de l'expérience dans un domaine qu'il ne connaît pas, ou peu.
il focalise sur le besoin, l'objectif immédiat.
l'accomplissement de ses tâches nécessite des recettes, une marche à suivre.
il n'a pas d'intuition sur la manière de résoudre les problématiques

étape 2: Débutant avancé

il fait preuve d'indépendance technique et sait chercher l'information nécessaire à l'accomplissement de ses tâches.
il sait choisir quelle démarche et technique appliquer selon le contexte.
il ne comprends pas ou peu la stratégie globale du système, de l'entreprise; il ne voit généralement pas les liens avec son travail quotidien.

étape 3: Compétent

il peut développer et utiliser des modélisations des problématiques et travailler par abstractions.
il peut résoudre des problèmes qu'il n'a pas rencontré auparavant.
on dit d'eux qu'ils font preuve d'initiative.
il ne réfléchit pas ou peu sur ses méthodes de travail, ne rentre pas dans un processus d'amélioration continue.

étape 4: Spécialiste

il ressent le besoin de comprendre la vue générale et les détails, la sur-simplification le frustre.
il corrige ses erreurs.
il apprend par l'expérience des autres, étudie des cas, des projets et prends ce qui peut améliorer son expertise.
il comprends et applique des maximes, vérités essentielles "Fait le minimum qui peut fonctionner", "Ne te répète pas", "Teste tout ce qui peut casser", ...
il sait utiliser les modèles de conception quand nécessaires (ce ne sont pas des recettes) et les adapter .
il utilise les avantages de la réflexion et du retour d'informations qui sont au cœur des méthodes agiles

étape 5: Expert

il cherche continuellement des nouvelles méthodes et manières de mieux faire les choses.
il travaille par (bonne) intuition.
il peut avoir du mal à expliquer ses choix: ils lui semblent "naturels".
il distingue les détails futiles de ceux très importants.
peu d'experts existent: certainement entre 1 et 5 pourcent de la population.

A noter qu' on peut être expert dans un domaine et totalement novice dans un autre.

Si le novice ne cherche pas à diversifier son expérience (ou ne suit pas de formation), il peut rester novice dans ce domaine quelque soit le nombre d'années d'activité. De même pour passer de débutant à compétent.

Nous tendons à penser que la plupart d'entre nous est au niveau "Compétent". Or il apparaît en pratique que la grande majorité est au stade "Débutant avancé".

Nous nous estimons aisément expert d'un domaine et sûr de nos choix lorsqu'on possède peu de compétences et connaissances de ce domaine. Un novice ne connaît peu ou pas les limites de son savoir. Plus on est expert, plus on doute, on se sent ignorant.

Cette citation (approximative) de Ghandi (je crois) me revient à l'esprit:
"Vivez comme si vous alliez mourir demain. Apprenez comme si vous étiez immortels."

Génération d'accompagnement musical

2009-04-28T22:38:00.005+02:00

MMA génère des accompagnements en format midi, ce qui nous permet travailler son instrument en improvisant sur les arrangements que l'on veut.

MMA génère l'accompagnement à partir d'un fichier texte dans lequel on spécifie au minimum le tempo, le style d'accompagnement et la grille du morceau. Par exemple:


Tempo 160

Groove Swing1
1 Cm7
2 Cm7
3 Ebm7
4 D7b5

génèrera ceci.

MMA est capable de générer des arrangements plus complets, comme celui-ci.

Avec un instrument dans une main, j'ai du mal à éditer des fichiers. J'ai généralement besoin d'un accompagnement minimal rapidement. LEMMA, une interface graphique à MMA, nous facilite la tâche.

L'utilisation de MMA requiert au préalable l'installation d'un synthétiseur logiciel midi. Une solution est d'utiliser timidity. Voici la procédure sous Arch Linux, mais toutes les grandes distributions proposent les paquets nécessaires.

Installation de timidity (synthétiseur midi):
pacman -S timidity++

Installation des sound fonts:
yaourt -S fluidr3

Ouvrez le fichier de configuration de timidity /etc/timidity++/timidity.cfg et ajoutez la ligne suivante pour indiquer d'utiliser la soundfont fluidr3:
soundfont /usr/share/soundfonts/fluidr3/FluidR3GM.SF2

Pour valider le fonctionnement de timidity, téléchargez le fichier midi demo1.mid et jouez le en tapant:
timidity demo1.mid

Vous pouvez aussi afficher une interface graphique pour contrôler la lecture avec l'option -ik (pour utiliser la bibliothèque Tk) ou -ig (pour GTK):
timidity -ik demo1.mid

A noter que l'on peut générer un fichier Ogg Vorbis depuis timidity avec l'option -Ov, ou bien Wav avec -Or. Pratique pour envoyer l'accompagnement à ses collègues.

Ceci fait, nous pouvons installer MMA depuis AUR (si python et tk ne sont pas installés, profitez-en pour le faire):
yaourt -S mma

Installation de Lemma:
yaourt -S lemma

Lancez lemma. Allez dans le menu Settings:

remplissez le champ Midi player: timidity -ik
cliquez sur Refresh grooves library

Vous êtes fin prêt à créer vos accompagnements.Saisissez quelques accords puis cliquez sur play pour écouter votre œuvre.

On peut changer le style de l'accompagnement au niveau de chaque mesure en cliquant sur Groove. Pour la suite je vous laisse consulter la documentation de MMA.

Configuration dvorak-bépo sous Arch

2009-04-26T09:48:00.006+02:00

J'utilise depuis quelques mois la disposition clavier dvorak-bépo. Voulant activer cette disposition dès le démarrage de X, j'ai tout d'abord modifié mon xorg.conf ... sans succès. Le problème viens du démon hal qui s'occupe maintenant de la configuration du clavier (entre autres).

Sous Arch, il faut procéder comme suit. Copiez tout d'abord le fichier de configuration du clavier de hal dans /etc:

cp /usr/share/hal/fdi/policy/10osvendor/10-keymap.fdi /etc/hal/fdi/policy/

Editez ensuite le fichier /etc/hal/fdi/policy/10-keymap.fdi et modifiez les valeurs des options input.xkb.layout et input.xkb.variant:

<merge key="input.xkb.layout" type="string">fr</merge>
<merge key="input.xkb.variant" type="string">bepo</merge>

puis redémarrez hal et votre gestionnaire de connexion (ici kdm)

/etc/rc.d/hal restart
/etc/rc.d/kdm restart

Dans mon cas, je remplace la touche Caps Lock par un Ctrl (je trouve ça plus pratique) et je fait tourner Arch sur un Macbook. J'ai donc rajouté la ligne suivante:

<merge key="input.xkb.options" type="string">lv3:rwin_switch,ctrl:nocaps,apple:badmap</merge>

Au revoir Debian, bienvenue Arch

2009-04-24T22:17:00.009+02:00

Neuf années que mon PC était fidèle à Debian (je me souviens avoir mis six heures à installer Potato dessus, grande victoire pour le novice Linuxien que j'étais). Mais là, de bricolage en bricolage, l'envie d'une réinstallation me trottait dans la tête depuis longtemps.

Quitte à ré-installer, autant essayer une autre distribution. D'autant plus qu'ArchLinux m'attirait.... ni une ni deux je télécharge l'iso, grave et lance l'installation. Le programme d'installation sobre et direct (connaissance minimale de Linux conseillée) se déroule sans problèmes. J'en profite pour formater mes partitions /usr et /var en ext4. Noyau 2.6.29.

Une fois installé et redémarré (ça démarre vite d'ailleurs), on se retrouve en mode console. Allons-y pour mettre en place le serveur X et KDE4, rien de bien sorcier; pacman s'utilise comme apt-get pour les commandes de base.

pacman -S xorg-server hal kdebase kdebase-workspace

Les paquets s'installent plus rapidement que sous Debian (pacman est toutefois moins avancé que apt). Démarrons le minimum vital:

/etc/rc.d/hal start
/etc/rc.d/kdm start

et nous voilà sous l'écran de connexion.

Pour avoir hal et kdm au redémarrage de la machine, le plus simple est de les déclarer dans le fichier /etc/rc.conf

DAEMONS=(hal kdm syslog-ng network netfs crond)

Après deux semaine sous Arch j'apprécie la simplicité de ce Linux avec des fichiers minimaux de configuration. Du coup mon portable a aussi adopté Arch sans regrets.