It-Signal

Ma config VIM

maxime@werlen.fr — Tue, 31 May 2016 00:00:00 +0000

J’utilise beaucoup VIM pour rédiger de la documentation et pour l’édition de configurations sur les serveurs. Avoir une configuration personnalisée est vraiment très agréable, mais il est complexe de maintenir la configuration identique sur toutes les machines. J’avais tenté de stocker mon .vimrc avec mes autres dotfiles sur git, mais à l’usage ce type de script (.bashrc…) est difficile à maintenir sur plusieurs plateformes Ubuntu, Centos, Windows avec Git Bash…

Suite à la lecture d’un article sur la configuration de VIM “from scratch” j’ai décidé de reprendre ma configuration et de ne versionner que mon dossier .vim. Le fichier .vimrc est un lien symbolique vers un fichier du répertoire .vim. L’article est très intéressant et propose des extensions pratiques. Voici le résultat maintenant que mon VIM est correctement configuré :

Todotxt

maxime@werlen.fr — Sun, 22 May 2016 00:00:00 +0000

Une petite note rapide pour vous parler de todotxt, un gestionnaire de tâche universel. Tout l’intérêt tient dans la simplicité du système : les tâches sont stockées sous forme d’un unique fichier texte. Une syntaxe toute simple permet de spécifier la priorité, la catégorie et l’échéance des tâches. De nombreux clients existent pour manipuler cette liste de tâches : des applications pour smartphones, des plugins pour les logiciels de messagerie et aussi un client en ligne de commande. C’est ce dernier que j’utilise au quotidien pour gérer ma liste de tâches personnelle et professionnelle. Le système d’alias de bash me permet d’avoir une commande simple (t par exemple pour ma liste de tâches professionnelles) qui m’affiche la liste des tâches à réaliser.

Bref, un outil très pratique qui couplé avec Dropbox permet d’avoir sa liste de tâche toujours avec soi. Je vous invite à vous pencher sur la liste des extensions, bien fournie, qui permet d’ajouter plein de fonctionnalités utiles (gestion des répétitions, rapports…)

WorkTips

maxime@werlen.fr — Sat, 09 Jan 2016 00:00:00 +0000

Depuis plusieurs mois j’écris très peu d’articles. Le peu de temps que j’investis sur le blog est entièrement consacré à faire avancer une présentation sur la programmation fonctionnelle. Je me suis lancé sur cette présentation après avoir suivi un MOOC sur le sujet. Depuis je n’ai jamais eu d’occasion de mettre en pratique cette formation.

Mon activité professionnelle m’amène à passer tout mon temps à faire de la gestion de projet, du support technique, du management, mais très peu de développement. Plutôt que d’essayer de vous parler de programmation alors que je n’en fais presque plus, je vais essayer de vous parler ce que je fais. Je voudrais commencer par une série nommée worktips dans laquelle je vous présenterais les conseils que je donne autour de moi. Ces courts articles parleront principalement des outils et des méthodes que j’utilise pour m’organiser.

Le management est encore un sujet récent pour moi, mais je m’intéresse beaucoup. J’essaierai de faire quelques articles pour vous présenter ma vision des choses.

J’espère être plus assidu cette année sur ce blog :)

Sécurisation des mails

maxime@werlen.fr — Sun, 22 Feb 2015 00:00:00 +0000

Ces derniers temps je me suis intéressé à la configuration et à la sécurisation d’un serveur de mail. Mon but initial était de pouvoir m’envoyer des mails de mon adresse Gmail sur une adresse locale et inversement. Cette première étape a été rapidement franchie grâce à l’installation d’un postfix et d’un dovecot, mais Gmail mettait systématiquement mes mails en spam.

Les normes d’authentification

En creusant j’ai découvert tout un ensemble de systèmes d’authentification des mails : SPF, DKIM et DMARC. Ces normes permettent d’améliorer l’authentification du premier MTA (le premier relais mail qui a reçu le mail de l’émetteur). En mettant en place toutes ces normes (principalement des enregistrements DNS et des configurations de postfix) Gmail a accepté mes mails : mission réussie. Il me restait néanmoins un arrière-gout d’inachevé, pourquoi s’arrêter au premier MTA, pourquoi ne pas authentifier l’émetteur directement ?

GPG et la cryptographie

J’ai toujours été intéressé par la cryptographie et ses domaines annexes comme la gestion de certificat (j’ai ma petite PKI personnelle), la signature électronique (je signe les PDF que je produis) et l’archivage probant (non, ma folie a des limites, je n’ai pas de coffre-fort électronique). En me renseignant sur l’authentification de l’émetteur je me suis rendu compte que toutes les technologies étaient basées sur de la signature électronique, soit en X.509 avec par exemple Outlook ou Thunderbird soit avec GPG. X.509 souffrant de trop nombreux problèmes pour que j’y fasse réellement confiance, j’ai décidé d’explorer GPG que je n’avais fait que survoler jusque-là.

J’ai suivi quelques tutoriels pour créer et publier ma clé GPG (vous la trouverez sur ma page contact). J’ai configuré mes clients mail pour signer mes messages sortants. Tout cela fonctionne parfaitement.

Un BBL

Pour ne pas garder le fruit de toutes ces recherches uniquement pour moi (j’ai bien essayé de partager avec ma femme, mais ça ne l’intéresse pas), j’ai décidé d’en faire une présentation dans mon entreprise. En effet, tous les mois j’organise un BBL (pour Brown Bag Lunch), il s’agit d’un repas où chacun amène son repas (d’où les sacs bruns) et où l’un des participants présente une technologie ou sujet qui l’a intéressé. Ce mois-ci c’était moi avec ma présentation sur la sécurisation des mails. J’ai beaucoup appris en réalisant cette présentation devant un public exigeant de développeurs et d’administrateurs systèmes et j’espère qu’eux aussi ont appris quelque chose.

Microdata

maxime@werlen.fr — Tue, 20 Jan 2015 00:00:00 +0000

En faisant un tour sur le service Webmaster Tools de Google je me suis rendu compte qu’ils avaient ajouté une section sur les Microdata. Cette norme permet d’ajouter dans une page HTML des informations standardisées permettant un traitement automatisé de l’information.

Je l’utilise par exemple sur ce site pour indiquer sur chaque page qu’elle fait partie d’un blog personnel s’intitulant “It-Signal” dont je suis l’auteur et que le post de blog est publié sous licence CC-BY-NC-SA. Ce type d’informations évidentes pour les utilisateurs humains sont plus complexes à obtenir pour un web-crawler. L’insertion de ces balises Microdata favorisent la compréhension de son site par les moteurs de recherche et permettent la création de résultats de recherche mieux présentés.

Ce n’est malheureusement pas encore bien au point chez Google puisque seuls certains types d’informations sont pris en compte (comme les revues d’objets ou les recettes par exemple):

Pour tester la bonne mise en place de vos balises vous pouvez vous aider de l’outil de test de Google (encore).

Always @ Home

maxime@werlen.fr — Sun, 05 Oct 2014 00:00:00 +0000

J’ai depuis quelques années un petit serveur chez moi que j’utilise pour plein de choses différentes (hébergement d’un serveur de streaming audio/vidéo, média-player, hébergement de photo, serveur de fichier). J’ai régulièrement besoin de m’y connecter, généralement en SSH, mais ce n’est pas toujours aussi simple.

SSLH

J’ai découvert SSLH lorsqu’un firewall a bloqué mon accès SSH à mon serveur perso. Pour contourner cette limitation, j’ai installé SSLH qui est multiplexer SSL/SSH. Les deux protocoles peuvent ainsi utiliser le port 443 qui n’est presque jamais fermé. Selon la séquence de handshake, le multiplexer redirige le flux vers le serveur Apache qui prendra en charge le SSL ou vers le serveur SSHD qui prendra en charge la session SSH. Le service est très simple à installer et très efficace.

VPN

J’utilise depuis quelques mois un serveur VPN (openvpn) hébergé sur mon serveur perso. Il me sert principalement à accéder à des services que je ne souhaite pas ouvrir sur internet (backoffice douteux de certains logiciels…). Toutes les connexions VPN arrivent par sécurité dans une zone IP séparée. Le firewall de mon serveur n’autorise ainsi que quelques services à être accédés depuis cette zone. J’ai généré les clés nécessaires à partir de ma petite PKI personnelle (avec ma clé root autosignée). Les configurations sont installées sur tous mes devices : ordinateurs perso et pro et téléphone portable.

Tous ces petits outils sont bien utiles pour administrer à distance mon petit serveur perso. Je vous recommande de jeter un oeil à ces outils avant d’être bloqué derrière un firewall trop strict :)

Mon premier ordinateur : un Z88

maxime@werlen.fr — Fri, 19 Sep 2014 00:00:00 +0000

Je suis partit récemment à la recherche du nom du premier ordinateur que j’avais eu dans les mains. La recherche a été longue, ma mémoire de poisson rouge n’aidant pas, mais j’ai réussi à retrouver la trace du Cambridge Z88.

Cambridge Z88

Cet ordinateur portable disposait d’un processeur 3 Mhz, de 32 Kb de RAM et un disque de 128 Kb (une cartouche EPROM). L’écran monochrome était limité à 8 lignes. Les batteries étaient tout simplement des piles AA. Ca pesait moins d’un kilo.

Quelques années après la sortie du Z88, mon père avait ramené de son travail un exemplaire dont l’écran était abimé (les 3 dernières lignes étaient inutilisables et le stockage n’était plus persistant). Entre 10 et 15 ans, j’ai régulièrement joué avec cet ordinateur. J’utilisais l’éditeur de programme en BASIC pour créer des petits jeux pour tromper l’ennui des après-midi pluvieuses.

Ça m’a fait un petit pincement au cœur de revoir ce cher Z88.

Un blog tout en markdown

maxime@werlen.fr — Thu, 18 Sep 2014 00:00:00 +0000

Ça fait maintenant un an que j’ai mis en ligne ce site. J’en suis plutôt content. Toujours basé sur Jekyll, je l’ai fait évoluer récemment en ajoutant du grunt pour gérer le build. J’en suis encore plus content. Petit retour d’expérience…

Jekyll

Jekyll n’est pas extraordinaire, mais il a l’avantage d’être hébergé par Github. Le push-to-deploy est un petit miracle. C’est tellement agréable de pousser un commit avec un fichier markdown pour voir apparaitre un article joliment mis en forme.

La mise en place est un peu longue (configuration des layouts, style, pages annexes…) mais après c’est très efficace pour la publication d’article : on écrit juste le texte en markdown et ça rend bien. La syntaxe markdown est simple à apprendre : c’est très intuitif.

Grunt

J’utilise depuis longtemps Grunt dans le cadre professionnel. Ca permet d’industrialiser la construction des projets Javascript : vérification des scripts javascript avec jshint/jslint, concaténation et minification des fichiers, etc… Ca apporte aussi, très simplement, le live-reload : le rechargement de votre page dans le navigateur lorsque les sources changent.

C’est lorsque j’ai voulu préparer des présentations que j’ai eu besoin de voir régulièrement la version web de la présentation. Jekyll met une paire de secondes pour générer le site à chaque changement, il faut ensuite changer de fenêtre pour recharger la version web. Trop long, trop lourd. J’ai mis en place du live-reload et j’en suis content (encore).

Remark.js

Pour mes présentations, j’ai décidé d’utiliser un framework javascript : Remark.js. Il permet d’écrire en markdown (encore) des slides de façon assez simple. Le markdown est parsé par la remarkjs qui créé les slides au runtime. Le rendu est propre et le framework propose des fonctionnalités sympa (gestion des notes, mode présentateur comme PowerPoint avec écran déporté, slides incrémentales, etc…). J’ai encore un peu de mal à adhérer. Pour des slides très formatée ça fonctionne bien, mais dès que l’on essaie de varier la présentation, c’est plus laborieux. Par exemple, j’aime beaucoup les slides très épurée avec juste une image ou quelques mots, dans ce cadre là, créer les styles CSS nécessaire à chaque fois est très contraignant.

J’utilise l’outil depuis très peu de temps. Je vais essayer de persévérer encore un peu pour voir si j’arrive à l’utiliser de façon agréable et efficace. Je vous tiendrais au courant.

Scala et la programmation fonctionnelle

maxime@werlen.fr — Sat, 02 Aug 2014 00:00:00 +0000

J’ai suivi il y a quelques mois une formation à la programmation fonctionnelle avec Scala sur coursera. La formation est assurée par Martin Odersky de l’Ecole Polytechnique Fédérale de Lausanne (EPFL), créateur du langage Scala. J’ai adoré la formation et j’ai même rempilé pour une seconde série de cours sur la programmation réactive.

Avant de me lancer dans ces cours, j’avais entendu parler de programmation fonctionnelle et je connaissais vaguement les grands principes de ce type de langages, mais je n’avais jamais réellement codé avec un langage fonctionnel. J’avais envie de découvrir de nouveaux langages sur la JVM, Scala me semblait un bon choix, malgré les critiques que j’ai pu entendre par-ci par-là (les Cast Codeurs ?).

L’histoire des langages informatiques

Les premières vidéo ont abordé l’histoire des langages informatiques et quelque grands concepts de programmation : les notions de stratégies d’évaluation (par valeur ou par référence), la récursion, les opérateurs fonctionnels, le currying…

Il m’a semblé intéressant de sortir du carcan de la programmation objet Java pour aller explorer les paradigmes des autres langages de programmation. Dans mon travail de tous les jours, Java “classique” est omniprésent, à tel point que j’en oublie qu’il existe d’autres façons de modéliser un programme (programmation évènementielle, programmation logique…).

Toutes ces notions sont importantes pour élargir notre vision de l’informatique et nous permettre de choisir au quotidien la solution la plus adaptée au problème. Avec Java on a tendance à avoir un marteau et à voir tous les problèmes comme des clous.

La programmation fonctionnelle

Pendant les cours sur Coursera, les enseignants ont pris de temps d’expliquer les principes sous-jacents à la programmation fonctionnelle et ça permet de mieux s’approprier les concepts. J’ai beaucoup aimé la simplicité et l’élégance du code fonctionnel écrit en Scala. Une fois le code écrit (ce qui n’est pas simple), tout semble clair et élégant.

Lors de la conférence MixIt 2014, j’ai assisté à un atelier sur Akka (un framework basé sur des acteurs écrit en Scala). Il était possible de réaliser l’atelier en Java ou en Scala (j’ai galéré pour réussir à le faire en Scala). Les réponses étaient beaucoup plus lisibles et élégantes en Scala qu’avec Java. Faire de la programmation fonctionnelle permet de simplifier l’écriture de son code mais il faut avoir les bons outils, Java donne l’impression de ne pas être encore bien adapté pour écrire simplement du code fonctionnel élégant.

La programmation réactive

La seconde partie du cours s’attarde sur la programmation réactive qui est à la mode en ce moment. Il s’agit juste d’utiliser les possibilités offertes par la programmation fonctionnelle pour rendre son application plus rapide et plus efficace possible. La gestion évènementielle et asynchrone des opérations à réaliser est bien sûr au coeur de du fonctionnement. Scala propose de manipuler simplement des Promises et des futures ; on peut construire des Streams de données que l’on agrège en temps réel avec seulement quelques lignes de code.

Le cours s’est terminé sur un TP très intéressant où l’on a réalisé une base de donnée clé-valeur minimaliste mais répartie sur plusieurs noeuds, avec du failover, de la redondance et de la persistance. Le tout est construit autour du framework Akka qui apporte le support des acteurs dans Scala.

Conclusion

Je n’utilise pas Scala quotidiennement mais ce cours m’a été particulièrement utile pour comprendre le paradigme fonctionnel. Je réutilise mes connaissances sur les patterns fonctionnels lorsque je développe avec Javascript (les promises d’Angular $q n’ont plus de secrets). Dès que mes projets auront migré sur Java 8, je pourrais reprendre la programmation fonctionnelle avec les nouveaux Streams et les lambda.

En plus de toutes ces connaissances, j’ai reçu les deux certificats Coursera (avec distinctions) délivré par l’EPFL et Coursera. Pour approfondir encore plus ces connaissances, je prépare en ce moment une présentation théorique et pratique sur la programmation fonctionnelle.

XBMC on Headless Server

maxime@werlen.fr — Thu, 17 Jul 2014 00:00:00 +0000

Un court article pour expliquer comment lancer un serveur X dédié à un processus sur un serveur headless. Il suffit d’utiliser la commande xinit disponible dans le package du serveur X : xorg. J’utilise par exemple cette commande pour lancer un service XBMC (un super media-center) sur mon serveur Ubuntu qui ne dispose pas d’interface graphique.

Voici, pour l’exemple, le script de lancement du service :

#! /bin/sh

### BEGIN INIT INFO
# Provides:          xbmc
# Required-Start:    $all
# Required-Stop:     $all
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: starts instance of XBMC
# Description:       starts instance of XBMC using start-stop-daemon and xinit
### END INIT INFO

############### EDIT ME ##################


# path to xinit exec
DAEMON=/usr/bin/xinit

# startup args
#DAEMON_OPTS=" /usr/bin/xbmc --standalone -- :0"
DAEMON_OPTS=" /usr/bin/xbmc"

# script name
NAME=xbmc

# app name
DESC=XBMC

# user
RUN_AS=xbmc

# Path of the PID file
PID_FILE=/var/run/xbmc.pid

############### END EDIT ME ##################

test -x $DAEMON || exit 0

set -e

case "$1" in
  start)
     echo "Starting $DESC"
     start-stop-daemon --start -c $RUN_AS --background --pidfile $PID_FILE  --make-pidfile --exec $DAEMON -- $DAEMON_OPTS
     ;;

  stop)
     echo "Stopping $DESC"
     start-stop-daemon --stop --pidfile $PID_FILE
     ;;

  restart|force-reload)
     echo "Restarting $DESC"
     start-stop-daemon --stop --pidfile $PID_FILE
     sleep 5
     start-stop-daemon --start -c $RUN_AS --background --pidfile $PID_FILE  --make-pidfile --exec $DAEMON -- $DAEMON_OPTS
     ;;

  *)
     N=/etc/init.d/$NAME
     echo "Usage: $N {start|stop|restart|force-reload}" >&2
     exit 1
     ;;
esac

exit 0

Une commande utile et simple à utilser qu’il ne faut pas oublier.