Niveau à bulle d'air, une idée de nanoprojet

Le niveau à bulle est un dispositif hydrostatique destiné à vérifier l'horizontalité d'une surface. On peut le simuler très facilement avec un dispositif qui possède

  • un écran (pour dessiner la bulle)
  • un accéléromètre (pour connaître le vecteur à afficher)

Or le Sense Hat et les tablettes tactiles possèdent ces deux outils, et le nano-projet présenté ici consistera juste à lire les coordonnées du champ gravitationnel pour les afficher à l'écran. En effet, ce champ est un vecteur vertical g, dont les coordonnées valent environ (0;0;-9,8) et si l'appareil est vertical, sa projection sur la tablette doit être le vecteur nul (bulle au centre de l'écran). Cependant, si on penche la tablette vers la gauche, la projection de ce vecteur sur la tablette aura une abscisse négative (du moins en mode "paysage") ce qui ferait aller la bulle vers la gauche si on ne gardait que l'abscisse et l'ordonnée de g: En fait, lorsque le niveau à bulle est incliné vers la gauche, l'eau descend et la bulle monte. Donc pour savoir où dessiner la bulle, on

  1. lit les coordonnées (x,y,z) de g, via l'accéléromètre
  2. garde seulement x et y vu que l'écran est en 2D
  3. change leur signe pour que la bulle monte au lieu de descendre
  4. dessine la bulle sous la forme d'un cercle de rayon constant et centré sur (x,y) ou plutôt sur (kx,ky) où k est un nombre négatif destiné à rendre l'appareil réaliste (pas trop sensible par exemple)

Sur le Sense Hat, on a un problème supplémentaire: Pas facile de dessiner un disque sur une matrice de 64 LEDs. Alors on le fait flou, sur 2 pixels de rayon, avec une formule trouvée par essais et erreurs. En plus, on quitte le programme dès que la bulle arrive au bord de la matrice de LEDs pour éviter les messages d'erreurs. Cela se fait avec une variable booléenne on_continue, par défaut à "true" (pour qu'on continue) et on boucle tant qu'elle est à "true". Quand la bulle arrive au bord de l'écran, on positionne cette variable à "false" pour quitter la boucle:

from sense_hat import SenseHat

sense = SenseHat()
on_continue = True


while on_continue:
        vecteur = sense.get_accelerometer_raw()
        x = -vecteur['x']*2 + 3.5
        y = -vecteur['y']*2 + 3.5
       
        for i in range(8):
                for j in range(8):
                        n = int(100*max(2-(i-x)**2-(j-y)**2,0))
                        sense.set_pixel(i,j,n,n,n)
       
        if (x-4)**2>20 or (y-4)**2>20:
                on_continue = False

Avec 13 lignes de Python, c'est même petit pour un mini-projet.

Il reste donc un peu de place pour montrer comment des élèves d'ICN (ou d'ISN) peuvent rapidement programmer un niveau à bulle pour leur propre smartphone. C'est aussi facile que sur le Sense Hat, grâce à app inventor, qui permet de créer des applications Android en déplaçant des blocs comme Scratch et Blockly. L'application étant elle-même en ligne, il est envisageable de créer une application Android sur la tablette directement. Cependant, un ordinateur est quand même bien pratique. Pour tester l'appli, il est pratique d'installer sur un smartphone de test, l'application ai companion, qui remplace l'émulateur et accélère considérablement la phase de test. Donc, pour créer un niveau à bulle Android, on va sur le site app Inventor (à l'aide de Chrome et en se connectant depuis son compte gmail...), et on démarre un nouveau projet. La première phase de conception ressemble à un travail de webmestre: Placer des éléments à l'écran et leur donner un identifiant. Les éléments sont choisis dans la palette, et sont de trois types:

  • un rectangle (noir) remplissant l'écran (type "canvas")
  • un lutin en forme de disque (cyan) placé dans le rectangle, et capable de bouger (ici en modifiant ses coordonnées); de type "ball"
  • et un senseur (accéléromètre) invisible à l'écran

Le deux premiers éléments sont dans la palette graphique; on les rajoute à l'écran par cliquer-glisser (le canvas sur l'écran, le ball sur le canvas):

bulle1

Et le dernier élément est dans la palette "sensors"; on le glisse n'importe où sur l'écran virtuel vu qu'il sera en dehors de cet écran:

bulle2

La structure de l'écran devrait donc être celle-ci pour un niveau à bulle:

bulle3

En cliquant sur un des éléments, on peut modifier, tout à droite de la page, ses propriétés (taille couleur titre etc) dans la fenêtre "éléments". L'apprentissage de css est un atout pour cette phase. L'écran peut avoir, avec quelques réglages de ce genre, cet aspect:

bulle4

On a donc déjà une idée de ce que ça donne avant même d'allumer le smartphone de test. Noter que ci-dessus l'écran a été positionné en mode "portrait" ce qui va nécessiter d'échanger les coordonnées x et y, parce que le repère n'est pas le même pour l'écran et l'accéléromètre, du moins en mode portrait. Le test en temps réel avec le companion est pratique pour trouver comment donner un mouvement cohérent à la bulle. C'est en cliquant sur "blocks" qu'on commence à programmer, et il y a deux choses à faire:

  • gérer les sorties d'écran (demander à la bulle de rebondir si elle arrive au bord de l'écran)
  • déplacer la bulle à chaque relecture des coordonnées de g

Voici l'intégralité du code source de ce niveau à bulle d'air:

bulle5

Pour effectuer les tests, il faut allumer le smartphone (ou la tablette) Android (l'appareil sur lequel le companion a été installé), puis, en haut d'app Inventor, se connecter sur le companion (par la wifi donc il faut désactiver le mode avion):

bulle6

Ceci a pour effet de faire apparaître un code de 6 lettres à entrer sur le smartphone, ainsi qu'un QR-code à flasher pour avoir automatiquement le code de 6 lettres. Ensuite, à chaque modification d'un bloc, le smartphone se met à jour et on voit immédiatement l'effet de la modification en live.

Quand on trouve l'application suffisament au point, on peut l'exporter:

bulle7

Ceci a pour effet de placer dans le dossier "téléchargement" un fichier apk, qui peut ensuite être installé sur les smartphones des amis, parents etc.

Mais ce n'est pas tout: Comme avec Scratch, il est possible de partager ses projets (des fichiers xml avec l'extension "aia") sur le site du MIT, et de "remixer" ses propres projets ou ceux des autres abonnés au site. Le niveau à bulle d'air par exemple se trouve ici.

Le mot de Fibonacci

Il s'agit d'un intéressant exercice (assez simple en plus) de programmation, sur la concaténation de chaînes de caractères: On part de deux mots binaires "0" et "1", et on répète l'opération de remplacer simultanément le premier mot par le deuxième et le deuxième mot par la concaténation des deux mots; le mot de longueur infini obtenu "à la fin" est appelé mot de Fibonacci. Le but de l'exercice est d'estimer la proportion de "1" dans ce mot, en la mesurant sur des approximations finies (qui sont des mots très longs).

Dans le langage bash, la concaténation se note juste en collant les mots l'un derrière l'autre, donc (en mettant le symbole "$" devant le nom d'une variable pour connaître le contenu de la variable), ce programme bash calcule les approximations du mot:

u=1
v=0
for n in `seq 1 10`; do
    w=$v$u
    u=$v
    v=$w
    echo $v;
done 

Pour voir à quelle vitesse le mot grandit, on peut tester cette variante:

u=1
v=0
for n in `seq 1 20`; do
    w=$v$u
    u=$v
    v=$w
    echo ${#v};
done

Enfin, pour connaître la proportion de "1", on doit déjà compter les "1"; en bash, on partage ce travail entre grep qui extrait les "1", et wc ("word count") qui les compte (avec l'option "-l" qui compte les lettres au lieu des mots):

u=1
v=0
for n in `seq 1 10`; do
    w=$v$u
    u=$v
    v=$w
    echo $v | grep -o "1" | wc -l;
done

Cet exercice est donc relativement intéressant pour des débutants en bash, mais avec l'affectation simultanée et la méthode "count", Python est très adapté aussi; en plus on verra un gain graphique non négligeable.

Pour afficher les approximations successives du mot de Fibonacci:

u = "1"
v = "0"
for n in range(10):
	u,v = v,v+u
	print v

Pour la proportion de "0" dans le mot:

u = "1"
v = "0"
for n in range(20):
	u,v = v,v+u
	print 1.0*v.count("1")/len(v)

(avec Python 2 il faut multiplier par 1.0 pour que la division soit celle des réels, avec Python 3 il faut mettre des parenthèses après "print"...)

On voit une rapide convergence vers l'inverse du nombre d'Or:


0.6
0.625
0.615384615385
0.619047619048
0.617647058824
0.618181818182
0.61797752809
0.618055555556
0.618025751073
0.618037135279
0.618032786885
0.618034447822
0.6180338134
0.618034055728
0.618033963167
0.618033998522
0.618033985017
0.618033990176

Le choix de "0" et "1" comme lettres de l'alphabet permet de considérer le nombre 0,101101... dont les chiffres binaires sont les lettres du mot de Fibonacci. Ce nombre peut être converti en décimal avec ce script:

u = "1"
v = "0"
for n in range(10):
	u,v = v,v+u
	print int(v,2)/2.0**len(v)

Si des élèves ont fait ça en miniprojet et veulent continuer sur un projet, il est possible de passer au domaine graphique. Par exemple, on obtient un long mot binaire avec ce script Python:

u = "1"
v = "0"
for n in range(20):
	u,v = v,v+u
print v

On peut imaginer de représenter les "0" par des pixels blancs et les "1" par des pixels noirs, et dire que ce long mot binaire est une image en noir et blanc. Regarder cette image pour diverses longueurs de lignes possibles (la dernière ligne n'est pas complète). Le module Image de Python convient pour cela:

import Image

cmap = {'0': (255,255,255),
        '1': (0,0,0)}
u = "1"
v = "0"
for n in range(20):
	u,v = v,v+u

bitmap = [cmap[letter] for letter in v]
img = Image.new('RGB', (160, 120), "white")
img.putdata(bitmap)
img.show()

Ce script donne un dessin intéressant comme texture de tissu:

dessin du bitmap

texture dessinée avec le mot de Fibonacci d'ordre 20, dessiné avec des lignes de 160 pixels

Mais la tortue permet une autre illustration graphique, en remplaçant chaque "0" par "fd(3);" et chaque "1" par "lt(90);fd(3);" ou "rt(90);fd(3);" selon la parité de l'indice. "lt" est une abréviation pour "left" et "rt", pour "right", ce qui veut dire que si le "1" est en position paire, la tortue tournera vers la gauche d'un quart de tour, et sinon, elle tournera vers la droite. Un "0" ne la fait pas tourner du tout ("fd" est une abréviation pour "forward"). Le remplacement sera fait par une expression régulière (module re). Mais cette expression agit sur chaque lettre qu'elle trouve, et ne connaît pas l'indice. Du coup on va remplacer les "1" en position paire par des "2" qui seront ensuite remplacés par "rt(90);fd(3);". Mais là encore, une complication surgit: Les mots sont "immutables" en Python, ce qui veut dire que changer une lettre à un endroit donné, n'est pas possible. Alors on va

  • transformer le mot v en une liste de lettres (conversion en liste par list(v));
  • boucler dans cette liste, par pas de 2, puisque seuls les "1" en position paire doivent être remplacés par des "2";
  • dans cette boucle, tester si la lettre est un "1"; dans ce cas, la remplacer par "2";
  • finalement, retransformer la liste en un mot, avec ''.join(v).

On peut vérifier cet algorithme avec ce script:

u = "1"
v = "0"
for n in range(16):
	u,v = v,v+u

print v
v = list(v)

for lettre in range(0,len(v),2):
	if v[lettre] == "1":
		v[lettre] = "2"

v = ''.join(v)
print v

Ensuite, on transforme ce mot ternaire de Fibonacci en un programme Python, avec ces substitutions:

from re import *

v = sub("0","fd(3);",v)
v = sub("1","lt(90);fd(3);",v)
v = sub("2","rt(90);fd(3);",v)

Pour exécuter ce programme Python, il faut importer les méthodes de la tortue:

from turtle import *
exec(v)

La tortue dessine alors quelque chose comme ceci:

dessin de la fractale

fractale de Fibonacci dessiné par la tortue de Python

Pour en savoir plus, voir wikipedia

Chiffre de Cesar en bash

Comme les élèves d'ICN tendent à être à l'aise avec bash (et pas seulement cowsay!), une séance de cryptographie peut rapidement être faite en bash, qui ne nécessite pas de boucler sur les lettres du message à coder (la boucle étant remplacée par un "pipe"). Une difficulté lorsqu'on veut faire de la cryptographie (et particulièrement avec l'algorithme d'Al Kindi qui est basé sur la statistique) est d'obtenir un texte à crypter, sans avoir à écrire des lignes et des lignes de texte. La ligne suivante permet d'obtenir un texte de longueur raisonnable:

man factor > message.txt

Après ça, on va crypter le fichier message.txt et écrire le résultat dans un autre fichier codé.txt. Par exemple, pour remplacer les "a" par des "?" on fait

cat message.txt | tr "a" "?" > codé.txt

("tr" veut dire "traduire" ou "translater": Le chiffre de César est, géométriquement parlant, une translation). Avec less codé.txt on voit que le message codé commence par

NOM
       f?ctor - F?ctoriser des nombres

SYNOPSIS
       f?ctor [NOMBRE]...
       f?ctor OPTION

Il ne reste plus qu'à recommencer pour les autres lettres de l'alphabet, pour que le message soit codé! Le chiffre de Cesar consiste à remplacer chaque lettre de l'alphabet par celle qui se trouve 3 rangs (par exemple) plus loin dans l'alphabet. Ici, remplacer "a" par "d", "b" par "e" etc. Mais du coup, on doit remplacer "z" par "c": La permutation opérée sur l'alphabet est cyclique. Ce codage se fait avec

cat message.txt | tr "a-z" "d-za-c" > codé.txt

Les minuscules sont maitenant cryptées:

NOM
       idfwru - Fdfwrulvhu ghv qrpeuhv

SYNOPSIS
       idfwru [NOMBRE]...
       idfwru OPTION

Le plus simple pour coder aussi les majuscules est de faire

cat message.txt | tr "A-z" "D-zA-C" > codé.txt

Cet algorithme de cryptage est loin d'être parfait: Les chiffres ne sont pas cryptés, l'abondance de o' montre que "o" code "l" (qui est la lettre le plus souvent suivie d'une apostrophe), etc. Mais le décryptage est facile avec tr: Il suffit d'inverser les deux chaînes de caractères définissant le codage:

cat codé.txt | tr "D-zA-C" "A-z"

Les élèves peuvent choisir leur propre codage soit avec des variantes comme "F-zA-E" soit carrément en écrivant une permutation lettre après lettre, comme

tr "a-z" "azertyuiopqsdfghjklmwxcvbn"

Il reste alors du temps pour faire un peu de cryptanalyse avec l'algorithme d'Al Kindi: La lettre "e" étant la plus fréquente dans un texte en français, on compte les lettres dans le texte codé pour chercher laquelle intervient le plus souvent. Ou plutôt, on va demander à grep de compter: grep est un petit robot qui parcourt le texte pour chercher la lettre qu'on lui a demandé de chercher, de la même manière qu'un cochon du Périgord parcourt les arbres pour y chercher des truffes. Pour compter les "w" du message en clair, on peut faire

cat message.txt | grep w

Le problème c'est que ça affiche toutes les lignes contenant un "w", pas seulement le "w" lui-même:

       Aide en ligne de  GNU  coreutils :  <http://www.gnu.org/software/coreu‐
       Copyright © 2014 Free Software Foundation, Inc.  Licence  GPLv3+ :  GNU
       Documentation complète : <http://www.gnu.org/software/coreutils/factor>
       <fblinux  AT  wanadoo  DOT   fr>   et   les   membres   de   la   liste

La troisième ligne par exemple contient trois fois de suite la lettre "w"; compter les lignes fausserait les statistiques sur ce texte; et compter les lettres aussi, puisque d'autres lettres que les "w" sont affichées aussi. Pour mieux voir les "w", on peut faire

cat message.txt | grep --color w

Si grep sait dessiner en couleurs, il sait aussi faire le tri, et la variante suivante affiche tous les "w", uniquement eux, et un seul par ligne:

cat message.txt | grep -o w

Il suffit alors de compter les lignes du résultat avec "word count" (option -l comme "lignes"):

cat message.txt | grep -o w | wc -l

Pour savoir quelle est la lettre qui code "e", il suffit de recommencer ça sur le message codé, lettre après lettre, et regarder quelle est la lettre la plus fréquente. Pour cela, on va quand même boucler, sur les lettres de l'alphabet. Avec des choses comme

echo {a..z}
for l in {a..z}; do echo $l; done
for l in {a..z}; do printf $l; done
for l in {a..z}; do (printf $l\ ); done
for l in {a..z}; do (printf $l\ ; cat codé.txt | grep -o $l | wc -l); done

Ce script affiche un tableau (qu'il est tout-à-fait possible d'enregistrer dans un fichier csv à l'aide d'une redirection) et dont voici le début:

a 0
b 0
c 0
d 68
e 15
f 39
g 32
h 124
i 24
j 20
k 12
l 74
m 3
n 1

Avec le tableau complet, on voit que la lettre "h" est de loin la plus fréquente et on infère que "e" est codé par "h". Si on sait qu'il s'agit d'un chiffre de Cesar, on a fini de décrypter; sinon on continue avec la lettre "r" qui est la deuxième lettre la plus fréquente (et le "u" apparaît 96 fois dans le message codé).

Après la cryptanalyse, ou à la place si le temps manque, on peut créer une commande de cryptage, ce qui est l'occasion de faire de la création numérique (c'est le nom de la matière enseignée après tout), et d'aborder les tests. On crée un fichier nommé crypter.sh et on y écrit les lignes suivantes (avec nano par exemple, on peut le faire dans une autre console pour la commodité):

#!/bin/bash

if [[ $# -ne 2 ]]; then
	echo "Utilisation de cette commande :"
	echo "Il faut deux noms de fichiers :"
	echo " * Le premier est le fichier texte à coder"
	echo " * Le second est le fichier qui contiendra le texte codé"
	else
	cat $1 | tr "A-z" "D-zA-C" > $2
	fi

En cours d'élaboration on teste le fichier avec des choses comme echo $1 ou echo $#. Pour tester le fichier, on doit le rendre exécutable avec

chmod +x crypter.sh

Ensuite on crypte un fichier avec

./crypter.sh message.txt codé.txt

On peut même crypter par lot avec ce genre de boucle (qui renomme les "txt" en "cesar"):

for f in *.txt; do (touch ${f%.txt}.cesar; ./crypter.sh $f ${f%.txt}.cesar); done

Remarque: L'extension "sh" est facultative, et ne pas la mettre renforce l'impression d'avoir créé une nouvelle commande dans bash.

 ___________
( Dyh Fhvdu )
 -----------
   o
    o
        .--.
       |o_o |
       |:_/ |
      //   \ \
     (|     | )
    /'\_   _/`\
    \___)=(___/

Cowsay en ICN

Le langage bash présente plusieurs qualités intéressantes en ICN, ne serait-ce que la familiarisation avec le Raspberry Pi (et en passant, la redécouverte de l'ordinateur POP qui n'est accompagné par aucune formation). Aussi à Roland-Garros, le premier TD d'ICN a-t-il porté sur un peu de programmation bash (jusqu'aux boucles avec `seq 2010 2020`). Malgré la beauté des sorties des commandes tree et pstree, la commande vedette en bash est incontestablement cowsay. Les auteurs de Raspbian ne semblant pas connaître ce monument d'humour geek, cowsay n'existe pas par défaut sur Raspbian. Il faut donc au préalable connecter le Raspberry Pi sur le net et entrer cette ligne de commande:

sudo apt-get install cowsay

Pour préparer le terrain, ces lignes de commande très "fun" peuvent être testées:

apt-get moo
aptitude moo
aptitude -v moo
aptitude -vv moo

À ce stade, les élèves sont très réveillés! Les plus rapides constatant vite que -vvvvvv est le dernier chapitre de l'histoire, -vvvvvvv donnant le même résultat. Cowsay est alors présenté comme alternative à echo: Si on entre echo bonjour, on a juste ceci dans la console:

bonjour

Très bien, mais si à la place on fait cowsay bonjour, on a ceci:

 _________
( bonjour )
 ---------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

Le même affichage peut être obtenu avec echo bonjour | cowsay (on affiche bonjour mais on branche l'affichage sur cowsay).

La séance suivante ayant été consacrée aux réseaux, la découverte de ssh a mené à la suggestion de refaire comme la dernière fois mais à distance, les syntaxes de ssh et bash étant similaires. Sans grande surprise, la commande testée par les élèves a été cowsay.

Voir les élèves s'amuser avec cowsay est très enrichissant didactiquement parlant parce qu'on peut facilement rebondir dans la direction "choisie" par les élèves, et même dans la redirection 😉

Déjà, pour éviter qu'ils écrivent sans cesse le même texte avec cowsay "bonjour", on peut leur montrer le fonctionnement du pipe avec des choses comme

echo "bonjour" | cowsay
factor 2016 | cowsay
date | cowsay
ls *.py | cowsay
cat essai.py | cowsay
ps | cowthink

Rapidement, certains ont cherché birdsay, dogsay, etc
sans succès. Ce fut l'occasion de montrer la commande man, et de chercher comment modifier l'aspect de la vache avec

man cowsay

L'occasion de faire un peu d'anglais, en se concentrant sur le paragraphe suivant:

There are several provided modes which change the appearance of the cow depending on its particular emotional/physical state. The -b option initiates Borg mode; -d causes the cow to appear dead; -g invokes greedy mode; -p causes a state of paranoia to come over the cow; -s makes the cow appear thoroughly stoned; -t yields a tired cow; -w is somewhat the opposite of -t, and initiates wired mode; -y brings on the cow's youthful appearance.

Bien entendu, ce fut l'occasion de se familiariser avec l'historique
des lignes de commande pour essayer toutes les possibilités sans tout
refaire à chaque essai.

Heureusement, les élèves n'ont pas eu le courage de lire la page de manuel jusqu'au bout, sinon ils auraient découvert l'option -f et auraient pu faire des choses comme

ls | cowsay -f sodomized-sheep

Or les élèves d'ICN sont mineurs tout de même!

Ensuite, on a vu comment utiliser cowsay pour fabriquer plus ou moins automatiquement des fichiers texte avec des choses comme

cowsay "bonjour" >> texte.txt
cat texte.txt

On peut même faire des choses comme

cat texte.txt | cowsay

Comme dirait Cowth Vader:

 __________________
( Je suis ton zébu )
 ------------------
        \    ,-^-.
         \   !oYo!
          \ /./=\.\______
               ##        )\/\
                ||-----w||
                ||      ||

Combattre dans l'arène

Amis de l'ISN,

Je crois vous avoir parlé de www.codingame.com, un des nombreux sites qui permet de s'initier au codage tout en s'amusant. J'ai découvert The Great Escape, le premier des jeux dans la partie Multi (y'a une partie Solo que j'avais exploré jusque là). Il s'agit d'un jeu à 2 ou 3 joueurs placés dans une grille 9x9 qu'il faut parcourir de gauche à droite ou de droite à gauche ou de haut en bas (suivant quel joueur on est). Le but est d'atteindre son bord avant ses adversaires. A chaque tour on peut donc avancer dans une des 4 directions (les diagonales ne sont pas autorisées) ou alors, et c'est là que ça commence à se corser ^^, on peut poser un mur qui fait 2 cases (horizontalement ou verticalement).

modélisation par un graphe
recherche de plus court chemin
min-max
notion de distance
notion de coût
...
y'a pas mal d'algorithmique (plus niveau L2/L3 mais ça permet éventuellement d'illustrer, sans forcément faire tout coder par les élèves).

De plus même en créant un robot un peu bête qui fonce tout droit, s'il combat contre un autre du même niveau il a ses chances. J'avoue que mon robot n'est pas très fort 🙂 (trouver le bon chemin c'est facile, positionner intelligemment les murs est une autre histoire).

Le "Canard enchaîné" met le bec dans les TIC

Le "Canard enchaîné" n°4885 du 11 juin va bientôt disparaître des kiosques de La Réunion. Mais on y parle :

  • page 1, de Google, avec un bref article titré "Google oublie d'oublier", sur la manière de disparaître du net...
  • page 4, sur le contrat IBM-Lenovo pour l'armée française, titré "des espions chinois dans les ordinateurs de nos armées?"
  • Toujours page 4, un article sur les droits d'auteurs des livres numériques (ou "ebooks"), titré "Amazon donne ses langues aux chiens"
  • Enfin, page 8, le point sur l'affaire Snowden

Il peut y avoir là matière à un débat ou un travail de documentation (sans compter l'article très bref mais amusant page 5, sur la bénédiction des smartphones...)