Clément Delafargue

Retour des RMLL

divarvel — Fri, 15 Jul 2011 21:17:22 +0200

Du 9 au 14 juillet avaient lieu les douzièmes Rencontres Mondiales du Logiciel Libre. L'occasion de rencontrer tout un tas de libristes et de contributeurs dans une ambiance sympa et détendue. Des conférences et des keynotes très intéressantes réalisées par (entre autres) Richard M. Stallman et Benjamin Bayart.

Ces RMLL ont été l'occasion de présenter notre retour d'expérience sur différents projets libres menés à l'École Centrale de Nantes. Avec Morgan Magnin, Benjamin Vialle et Nelle Varoquaux, nous avons eu la chance de faire trois conférences autour de MarkUs, l'application de correction de TP, et d'OpenOffice.org.

Les supports de ces présentations, ainsi que de plus amples explications sont disponibles dans la suite de l'article.

Tab Candy: They're (poorly) reinventing the Wheel

divarvel — Thu, 29 Jul 2010 08:09:16 +0200

It's a fact, more and more applications are web-based, and the tabbed browsing shows its limits. Tabs are now like real applications and need to be managed more precisely and with less hassle. That's why the firefox folks created Tab Candy.

This is stupid. There are tons of good window managers out there. Why do anybody need to spend time on reinventing one, which won't be as good as existing ones, in addition to create a strong separation between web apps and the regular ones ?

If you want to have several groups of tabs, use several windows. If you want to have a quick access to a web app, give it its own window (with uzbl or jumanji for instance). This way, all your applications (web or regular) behave consistently, and you can use the full power of your WM instead of beeing forced to use a stoneage WM inside your browser.

Problem solved.

Environnement de développement Android - Sans Eclipse

divarvel — Mon, 31 May 2010 19:59:17 +0200

Je viens de faire l'acquisisition d'un Nexus One (j'étais lassé des restrictions à la Apple), et bien évidemment la première envie que j'ai c'est de développer des applis Android pour faire un peu joujou avec la bête.

J'ai trouvé pas mal de ressources pour débuter, mais toute ont pour point commun l'installation d'un CPU / Memory Hog : le tristement célèbre Eclipse.

Voici donc une petite compilation de ce que j'ai pu trouver pour déployer et utiliser un environnement de développement Android sous Ubuntu (#Insert troll here#), qui ne fasse pas appel à Eclipse.

MPD + Quelques tweaks sous Ubuntu

divarvel — Thu, 29 Apr 2010 06:03:09 +0200

MPD est, comme son nom s'indique, un daemon qui lit de la musique. L'intérêt, est que la partie qui lit la musique est découplée de l'IHM qui permet de gérer ça.

Cette structure apporte plusieurs avantages :

Légèreté (pas besoin d'occuper des ressources en permanence pour l'interface)

Choix du nombre d'interfaces (il y en a vraiment pour tous les goûts, du plus simple au plus sophistiqué, en passant par le sobre et efficace)

Possibilité de commander par le réseau
Interfaçage rapide avec tout et n'importe quoi (conky, par exemple)

J'ai donc installé et configuré MPD. (À l'aide de la doc d'ubuntu-fr).

J'ai eu ensuite à faire quelques petits tweaks pour intégrer ça correctement à mon système.

Touches multimédia

Comme MPD tourne en tâche de fond, si aucune interface n'est lancée, les touches multimédia ne seront pas gérées.
Le plus simple est d'utiliser mpc, qui permet d'envoyer des commandes à MPD.
J'ai ainsi associé la commande mpc toggle à la touche XF86Play, mpc stop à la touche XF86Stop, et ainsi de suite.

Pour le fun, j'ai fait un petit script qui permet d'afficher les informations sur le morceau en cours à l'aide de libnotify.

#!/bin/sh
DISPLAY=:0
notify-send "`mpc --format "%title%"|head -n1`" "`mpc --format "%artist% - %album%"| head -n1`"

Rien de bien méchant, mais ça peut être utile quand on veut savoir le nom du morceau en cours sans perdre trop de temps.

Scrobbling

Les clients MPD sophistiqués gèrent le scrobbling, mais, comme je l'ai dit, on n'a pas besoin d'avoir une interface en permanence.

J'ai trouvé scrobd, un petit script python qui permet de scrobbler sur libre.fm. (Saymieux que last.fm, et on a moins de risques de voir son nom refilé à la RIAA)

Étant donné que tous les clients communiquent avec MPD par une interface TCP, il n'y a pas de difficultés particulières pour que la musique soit jouée sur un ordinateur distant, avec autant de facilité que si c'était sur son propre PC.

Pour plus d'informations :

Et merci à @Keruspe et @Efyx pour m'avoir aidé à faire mes premiers pas avec MPD

Passer de SVN à Git + Gitosis

divarvel — Fri, 12 Feb 2010 21:39:01 +0100

J'ai récemment réalisé la migration de tous les projets EklaWeb de Subversion vers Git.

Si vous voulez savoir pourquoi, je vous conseille cet excellent article de Scott Chacon
Pour résumer,

Git est plus rapide
Git est plus puissant
Git est plus flexible

J'ai ainsi migré 3 dépôts SVN vers Git très simplement

Un petit script pour faire du Benchmark

divarvel — Mon, 01 Jun 2009 16:38:34 +0200

Dans le cadre d'un travail demandé en cours de Théorie des Graphes, je devais regarder l'évolution du temps d'exécution d'un programme en fonction d'un paramètre. (Pour les curieux, c'est la k-Coloration d'un Graphe à n Sommets)

Je me suis bricolé un petit script qui fait ça tout seul, et génère un graphe (via l'excellent GnuPlot) (ou affiche les temps d'exécution)

C'est la première fois que je fais un vrai script en Bash (ie un script qui n'est pas 3 commandes mises à la suite), du coup, pour la structure, je me suis inspiré d'un petit script de P4bl0.

Le nom du programme à tester est hard coded, mais ce n'est pas très dur à modifier.

N'hésitez pas à vous en servir si ça vous est utile ;-), de même que toutes les critiques sont les bienvenues (je n'y connais pas grand chose (pour ne pas dire que dalle) en scripts Bash)

L'usage, c'est $[...]:~> ./bench.sh [-i n] p n1 n2 itv graphe.png
n1 valeur de départ du paramètre
n2 valeur finale du paramètre
itv variation du paramètre à chaque pas
graphe.png nom du fichier généré
Pour le -i n, n est le nombre d'exécutions du programme pour chaque point (par défaut, 10)

#!/bin/sh
if [ "$1" = "-i" ]; then
ITER="$2"
shift
shift
else
ITER="10"
fi

_bench_usage() {
cat < Usage: bench disp n1 n2 interval : Affiche le temps pris pour traiter des graphes de n sommets, n variant de n1 à n2 par pas de interval.
       bench plot n1 n2 interval file: Crée le fichier file, un graphique PNG affichant le temps pris pour traiter des graphes de n sommets,
                                   n variant de n1 à n2 par pas de interval.
       bench help: Affiche cette page d'aide.
La première lettre de chaque commande peut être utilisée
Le flag -i permet de spécifier combien de fois un graphe à n sommets doit être calculé.
Valeur par défaut : 10
USAGE
}

_bench_disp() {
i=$1
while [ $i -le $2 ]; do
    START=$(date +%s)
    _bench_run
    STOP=$(date +%s)
    echo "Graphe à" $i "sommets :" $[$STOP-$START] "secondes"
    i=$[i + $3]
done
}

_bench_plot() {
# Création d'un fichier temporaire contenant les données à afficher
i=$1
echo "# Temps de calcul pour des graphes de "$1" à "$2" sommets (par pas de "$3")" > plot.dat
while [ $i -lt $2 ]; do
    START=$(date +%s)
    _bench_run
    STOP=$(date +%s)
    echo $i $[$STOP-$START] >> plot.dat
    i=$[i + $3]
done

# Génération du graphe
gnuplot< set xlabel 'Nombre de Sommets du graphe'
set ylabel 'Temps de calcul (s)'
set xrange [*:*]
set yrange [*:*]
set grid
set nokey
set output "${4}"
set terminal png small
plot "plot.dat" with linespoints
EOF

# Suppression du fichier temporaire
rm -f plot.dat
}

_bench_run() {
j="0"
while [ $j -lt $ITER ]; do
    ../source/coloration -r $i -v 1>>coloration.log 2>> error.log
    echo "">>coloration.log
    echo "">>error.log
    j=$[j + 1]
done
}

_bench() {
local ACTION="$1"
shift
case $ACTION in
    d|disp) _bench_disp "$@" ;;
    p|plot) _bench_plot "$@" ;;
    h|help|*) _bench_usage >&2 ;;
esac
}

_bench "$@"

echo
exit 0

C'est facilement modifiable pour faire un comparatif entre deux programmes, à condition de regarder un peu la doc de GnuPlot.

Un peu de Conky

divarvel — Mon, 01 Jun 2009 16:23:48 +0200

J'avais déjà parlé de Conky sur ce blog, un outil très geek et très sympa.

Je me suis rebricolé une config hier (pendant que je je faisais un peu de benchmarking), à partir de ce super article

Je n'ai pas encore fini, il faut que je tweake le script qui va chercher les tweets pour le mettre un peu plus joliement en forme, et que je mette la météo.

À part ces deux trois trucs à finir, je suis vraiment content du résultat.

J'ai fait une version plus light pour mon EEE, qui rend vraiment bien niveau sobriété (ça se marie bien à OpenBox)

La prochaine étape, générer des graphes un peu plus complets avec GnuPlot (temps de latence de différents serveurs, le temps que je passe sur l'ordi, le cours du Yen, tout ça...)

Algorithmique et Programmation en LaTeX

divarvel — Mon, 30 Mar 2009 07:16:21 +0200

Cette année, j'ai des cours d'algorithmique et de programmation, du coup je fais mes rapports en LaTeX. Un de mes collègues m'a passé de quoi intégrer du code et des algorithmes dans vos rapports, et ce proprement et joliment.

Listings de Programmation

Pour afficher des bouts de code, rien de bien compliqué. On commence par charger l'environnement listing.

\usepackage{listings}

Ensuite, on le configure un peu.

\lstset{
language=C,
keywordstyle=bfseriesttfamilycolor[rgb]{0,0,1},
identifierstyle=ttfamily,
commentstyle=color[rgb]{0.133,0.545,0.133},
stringstyle=ttfamilycolor[rgb]{0.627,0.126,0.941},
showstringspaces=false,
basicstyle=footnotesize,
numberstyle=footnotesize,
numbers=left,
stepnumber=1,
numbersep=10pt,
tabsize=2,
breaklines=true,
breakatwhitespace=false,
aboveskip={1.5baselineskip},
columns=fixed,
upquote=true,
extendedchars=true,
}

Rien de bien sorcier dans la config, en bidouillant un peu, on peut obtenir ce que l'on veut (langage, espacements, etc...) Il suffit ensuite d'encapsuler le bout de code qu'on veut afficher dans un environnement lstlisting

\begin{lstlisting}
#include
int main(){
printf("Hello World");
return 0;
}
\end{lstlisting}

Algoritmique

Pour afficher des algorithmes dans vos documents LaTeX, rien de bien compliqué non plus, sauf qu'on va franciser un peu les packages dont on se sert (personnellement je trouve ça affreux, mais on est obligés de faire comme ça en cours :/). On commence par charger les packages.

\usepackage{algorithm,algorithmic};

On redéfinit ensuiteles commandes des packages algorithmic et algorithm.

% Francisation des algorithmes
\renewcommand{algorithmicrequire} {textbf{textsc{Entrées:}}}
\renewcommand{algorithmicensure} {textbf{textsc{Sorties:}}}
\renewcommand{algorithmicwhile}   {textbf{tant que}}
\renewcommand{algorithmicdo}      {textbf{faire}}
\renewcommand{algorithmicendwhile}{textbf{fin tant que}}
\renewcommand{algorithmicend}     {textbf{fin}}
\renewcommand{algorithmicif}      {textbf{si}}
\renewcommand{algorithmicendif}   {textbf{fin si}}
\renewcommand{algorithmicelse}    {textbf{sinon}}
\renewcommand{algorithmicthen}    {textbf{alors}}
\renewcommand{algorithmicfor}     {textbf{pour}}
\renewcommand{algorithmicforall} {textbf{pour tout}}
\renewcommand{algorithmicdo}      {textbf{faire}}
\renewcommand{algorithmicendfor} {textbf{fin pour}}
\renewcommand{algorithmicloop}    {textbf{boucler}}
\renewcommand{algorithmicendloop} {textbf{fin boucle}}
\renewcommand{algorithmicrepeat} {textbf{répéter}}
\renewcommand{algorithmicuntil}   {textbf{jusqu'à}}
\renewcommand{algorithmiccomment} {STATE //}
\newcommand{BEGIN}{STATE fbox{Début}}
\newcommand{END}{STATE fbox{Fin}}
\floatname{algorithm}{Algorithme}

Pour intégrer un algo dans son document LaTeX, il ne reste plus qu'à faire comme ceci :

\begin{algorithm}
\caption{Algo de test}
\begin{algorithmic}
    \require entiers a, b
    \ensure entier d
    \begin
      \state d $leftarrow (a+b)$
    \end
\end{algorithmic}
\end{algorithm}

Normalement, vous devriez avoir tout ce qu'il faut pour impressionn^Wfaire plaisir à votre prof d'Algo - Programmation préféré(e). Bon courage et bonne programmation !

Merci à Julien pour m'avoir passé ces bouts de code !

Créer son thème Beamer

divarvel — Sun, 01 Feb 2009 22:46:39 +0100

J'ai enfin (à peu près) compris comment créer un thème Beamer from scratch. Voilà la méthode (ce n'est en aucun cas un lexique de commandes). Pour les différentes commandes, ça se trouve facilement (ici et ici par exemple). J'écris cet article car il n'y a quasiment aucune ressource qui explique comment créer un thème entier (juste comment en modifier des existants).

Tout se passe dans les fichiers suivants (remplacez Theme par le nom de votre thème):

beamerthemeTheme.sty
beamerouterthemeTheme.sty
beamerinnerthemeTheme.sty
beamercolorthemeTheme.sty

Chaque fichier comporte la ligne :
\ProvidesPackage{beamercolorthemeTheme}[AAAA/JJ/MM] (color pour le fichier colortheme, à remplacer par inner, outer ou rien)

Le fichier principal est beamerthemeTheme.sty, c'est lui qui définit tout le reste (il contient les liens vers les trois autres fichiers de thèmes). Pour indiquer au compilateur d'utiliser votre fichier de thème, insérez la commande suivante \usetheme{Theme} dans la partie \mode{}.

Pour la structure des slides (fond, menu, etc...), ça se passe dans outertheme. Par exemple, pour définir le fond des slides :
\pgfdeclareimage[height=\paperheight,width=\paperwidth]{frame_bg}{frame_bg}
\setbeamertemplate{background}{\pgfuseimage{frame_bg}}
On définit une image (frame_bg.png) de la taille du slide (height=\paperheight,width=\paperwidth), puis on la met comme fond de chaque slide.

Pour les différentes couleurs (ici la couleur de fond des slides) :
\definecolor{couleur}{HTML}{F0F6F8}
\setbeamercolor{background canvas}{fg=couleur, bg=couleur}

Le innertheme définit le contenu des slides. J'ai pas trop d'idées de commandes à mettre dedans.

Voilà pour une brève explication de la méthode. Pour des explications des différentes commandes, je vous conseille l'excellent site mcclinews.free.fr, qui est complet et détaillé. Le passage sur les beamercolorbox est très intéressant et utile. Enjoy !

Faire ses présentations en LaTeX avec Beamer

divarvel — Tue, 13 Jan 2009 00:48:57 +0100

Depuis que je suis arrivé à l'ECN, les présentations PowerPoint sont devenues une norme : Les profs s'en servent pour les cours, les étudiants s'en servent pour les exposés : dès qu'on parle à plus d'une personne, il faut sortir le PowerPoint (et brasser, mais pour ça on nous donne des cours). Vous connaissez mon amour pour les produits Microsoft (qui est d'ailleurs partagé par notre Directeur des Études), donc je me suis d'abord dit que j'utiliserais OpenOffice.org Impress. En fait, je n'aime pas ces clic-o-drômes, c'est pour cette raison que j'ai sauté de joie quand j'ai appris qu'on pouvait faire ses présentations en LaTeX , et les exporter en format PDF, certes propriétaire, mais si bien géré sur toutes les plates-formes. Pas comme le .doc, qu'un abruti de prof a essayé de faire passer pour un standard. L'ISO ne reconnaît qu'un seul standard pour les fichiers bureautiques, et c'est... l'odf (fin bref...)

Pour ceux qui se le demandent, LaTeX est un langage de description de documents qui est super puisqu'il distingue le fond de la forme (ce que chérit par dessus tout un intégrateur xHTML qui se respecte), permet de gérer proprement la mise en page, et permet d'écrire de superbes formules mathématiques, et ce sans le moindre clic. il y a de quoi baver, sérieusement.

Pour vous donner une idée de ce que ça peut donner : Exemple de document

Un petit guide du débutant vous attend dans la suite de cet article.