Lettre à mon Député

Monsieur le Député,

Suite à la lecture de votre article sur le projet de loi sur le renseignement: http://www.jeanluclaurent.fr/Liberticide_a423.html

Je tenais à vous faire part de mes inquiétudes concernant ce texte et de mes désaccords.

En premier lieu, vous indiquez que vous ne légiférez pas dans l’urgence. Cette affirmation est fausse. En effet, le Gouvernement utilise la procédure accélérée réduisant la possibilité pour vous d’effectuer votre travail de parlementaire dans de bonnes conditions, en particulier sur un texte aussi technique.

En deuxième lieu, dans votre article vous affirmez que ce projet est précis. Or il y a un point sur lequel il y a un manque de précision, et ce de manière cruciale et que je formulerai sous forme de question : Quels sont les motifs de mise en place d’une surveillance ?

En effet le texte prévoit que les techniques de renseignements pourront être mises en oeuvre pour les motifs suivants:

• « 1° La sécurité nationale ;

• « 2° Les intérêts essentiels de la politique étrangère et l’exécution des engagements européens et internationaux de la France ;

• « 3° Les intérêts économiques et scientifiques essentiels de la France ;

• « 4° La prévention du terrorisme ;

• « 5° La prévention de la reconstitution ou du maintien de groupement dissous en application de l’article L. 212-1 ;

• « 6° La prévention de la criminalité et de la délinquance organisées ;

• « 7° La prévention des violences collectives de nature à porter gravement atteinte à la paix publique.

Si l’on peut être d’accord avec certains motifs, d’autres sont sujets à interrogations.

À titre d’illustration, d’après le point numéro deux, s’engager à l’encontre des engagements européens constituerait un motif valable de mise sous surveillance. Cela concernerait donc votre propre parti lorsque vous appelez à boycotter les élections européennes: http://www.mrc-france.org/Parlement-europeen-cette-election-derisoire-se-fera-sans-nous_a602.html

Concernant le point numéro 3, nous pouvons légitimement nous poser la question de savoir en quoi les intérêts économiques de la France constituent un motif valable de mise sous surveillance. Ainsi, un militant, qui s’opposerait aux intérêts d’une grande multinationale française, pourrait être légalement surveillé.

Le point numéro 7 apparaît beaucoup trop flou, car toutes les manifestations politiques pourraient tomber sous ce motif.

Je n’affirme pas que ce gouvernement met en place une Police politique. Cependant, en manquant cruellement de précision, le législateur laisse aux Gouvernements suivants la possibilité d’utiliser la loi dans leurs propres intérêts. L’affaire des écoutes de l’Élysée démontre que ce risque est réel.

En troisième et dernier lieu, concernant la surveillance généralisée, puisque c’est bien de cela dont il est question, comme vous le soulignez, cela n’est pas efficace. Les fameuses boites noires vont concrètement surveiller tout le trafic sur le réseau pour identifier les comportements suspects.

Affirmer le contraire est soit un mensonge du gouvernement soit un aveu d’inefficacité. Le Gouvernement joue sur les mots en utilisant le terme de “meta données”. En effet, si l’algorithme secret défense du gouvernement ne lira effectivement pas notre email, en revanche, il saura avec qui et quand l’on communique, ainsi que les pages web que l’on consulte. Ce système livre déjà de façon systématique aux autorités des pans entiers de notre vie.

Aussi, je vous invite à ne pas me croire sur parole, mais à vous adresser aux milliers d’étudiants en informatique présents dans votre circonscription.

Par ailleurs, un tel système n’aurait permis d’éviter les évènements tragiques de janvier, où le problème n’était pas les moyens de renseignement disponibles ou le repérage de la menace, mais un manque de moyens humains des services. En outre, les terroristes sont déjà formés à contourner cette surveillance.

Enfin, je ne conteste pas que le citoyen pourra saisir le Conseil d’État en cas de dérive. Mais comment le pourrait-il, car il sera impossible pour lui de savoir que l’on a fait l’objet d’une surveillance particulière qui est par nature secrète ?

Et que risque un agent qui aurait abusé de son pouvoir ? La question demeure sans réponse.

L’impact économique sur votre circonscription est déjà là. L’hébergeur Gandi dont le siège est à 300 mètres d’Ivry à indiquer que dans ces conditions il se développerait à l’étranger. http://fr.gandi.press/100409-loi-sur-le-renseignement-gandi-reste-mobilise

L’année dernière, la ville du Kremlin-Bicêtre accueillait une exposition sur Jean Jaurès. Souvenez-vous de son combat contre les lois scélérates qui furent déjà en leur temps prises pour protéger les citoyens de leurs mauvaises pensées.

Veuillez agréer, Monsieur le Député, l’expression de mes sentiments respectueux.

Julien Duponchelle
123 avenue de fontainebleau
Le Kremlin-Bicêtre

Développer pour le Jumping Sumo de Parrot sous Mac

Le Jumping Sumo de Parrot est un petit robot qui roule et peut sauter jusquà 80 cm de haut. Il est aussi équipé d’une Webcam.

Jumping Sumo

Voir sur amazon (lien d’affiliation): Parrot MiniDrone Jumping Sumo Noir

J’en ai reçu un en décembre et après avoir un peu joué avec l’appli android avec j’ai décidé de jouer avec le SDK fournis par Parrot.

Le SDK est en C, ce qui le rend assez facilement portable.

Installation du SDK

Le SDK est disponible sur Github

git clone https://github.com/ARDroneSDK3/ARSDKBuildUtils.git

Ensuite on va le compiler pour MacOS (des version IOS et Android sont disponible aussi, les instructions Mac devrait marcher sous Linux)

./SDK3Build.py -t Unix

Cette commande va télécharger tous les dépots nécessaire au bon fonctionemment du SDK et compiler ce dernier.

Compilation des examples

Faire bouger le jumping sumo

Un deuxième dépot avec des exemples est fournis:

git clone https://github.com/ARDroneSDK3/Samples

Le premier avec lequel on va jouer: Unix/JumpingSumoChangePosture.

On va donc dans le répertoire et on va compiler avec l’aide Make

make

Puis on se connecte en Wifi du Jumping Sumo Jumping Sumo Wifi

On peut enfin lancer le programme que nous venons de compiler:

# ./JumpingSumoChangePosture
[INF] JumpingSumoChangePosture | 13:16:35:579 | main:134 - -- Jumping Sumo Change Posture --
[INF] JumpingSumoChangePosture | 13:16:35:580 | ardiscoveryConnect:195 - - ARDiscovery Connection
[INF] JumpingSumoChangePosture | 13:16:35:622 | startNetwork:227 - - Start ARNetwork
[INF] JumpingSumoChangePosture | 13:16:35:624 | sendPilotingPosture:341 - - Send Piloting Posture 2
[INF] JumpingSumoChangePosture | 13:16:37:624 | sendPilotingPosture:341 - - Send Piloting Posture 1
[INF] JumpingSumoChangePosture | 13:16:39:626 | stopNetwork:296 - - Stop ARNetwork
[INF] JumpingSumoChangePosture | 13:16:39:643 | main:186 - -- END --

Votre programme devrait localiser automatiquement votre Jumping Sumo sur le Wifi et le faire bouger.

Récupérer la caméra

Un deuxième exemple fournis pour le Jumping Sumo est la récupération du flux de la caméra. Il se trouve dans le répertoire JumpingSumoReceiveStream.

De nouveau vous pouvez le compiler avec make:

make

Pour afficher le flux il vous faut la commande ffplay ffplay:

brew install ffmpeg --with-ffplay

De nouveau vous pouvez lancer le programme est vous admirer à travers les yeux du Sumo.

Jumping Sumo Camera

Piloter le Jumping Sumo

Le dernier exemple permet de piloter le Jumping Sumo via une interface très minimaliste en curses.

Jumping Sumo Curses

Avec cela combiné vous avez tout ce qu’il vous faut pour jouer sans être olbiger d’utiliser les applis smartphone.

La documentation

Un dépot avec de la documentation existe:

git clone https://github.com/ARDroneSDK3/Docs

Pour la liste des commandes disponibles vous pouvez regarder le fichier ARSDKBuildUtils/Targets/Unix/Install/include/libARCommands/ARCOMMANDS_Types.h

Conclusion

Parrot a fait du bon boulot pour la mise en oeuvre du SDK. A aucun moment je n’ai été bloqué. Et après avoir lu tous les exemples on a tout ce qu’il faut pour créer. Après on regrettera peut être que tous soit balancé sur Github et qu’on ne ressente du coup pas l’envie d’en faire quelque chose de vraiment communautaire (un site dédié à la documentation par exemple serait un plus).

PEP 8 Git pre commit hook

This pre commit hook will check the PEP8 syntax of your Python files and ask you if you want to continue the commit process.

In your project directory create a file: .git/hooks/pre-commit and add the execution permission on it.

#!/bin/bash

echo "Pre-commit started"
echo "PEP 8 check"
git diff  --cached --name-only | grep .py | xargs pep8

if [ $? == 0 ]
then
    exit 0
fi

# Allows us to read user input below, assigns stdin to keyboard
exec < /dev/tty

echo "Do you want to ignore warning?"
select yn in "Yes" "No"; do
    case $yn in
        Yes ) exit 0;;
        No ) exit 1;;
    esac
done

Asyncio blocking code

Asyncio is greats piece of software. But all Python code is not compatible. In the following example we will see how to run blocking code from your asyncio code.

We will by a simple asyncio application:

import asyncio
import time

@asyncio.coroutine
def clock():
    while True:
        print("Current time from asynchronous code: {}".format(int(time.time())))
        yield from asyncio.sleep(1)


def main():
    loop = asyncio.get_event_loop()
    asyncio.async(clock())
    loop.run_forever()

if __name__ == '__main__':
    main()

The output is:

Current time from asynchronous code: 1422265105
Current time from asynchronous code: 1422265106

And add blocking code:

import asyncio
import time

@asyncio.coroutine
def clock():
    while True:
        print("Current time from asynchronous code: {}".format(int(time.time())))
        yield from asyncio.sleep(1)

def blocking():
    while True:
        print("Current time from blocking code: {}".format(int(time.time())))
        time.sleep(1)

def main():
    loop = asyncio.get_event_loop()
    blocking()
    asyncio.async(clock())
    loop.run_forever()

if __name__ == '__main__':
    main()

The output is:

Current time from blocking code: 1422265410
Current time from blocking code: 1422265411
Current time from blocking code: 1422265412

If you want to run blocking code in your asynchronous code you need to run it in a different thread. Hopefully asyncio provide BaseEventLoop.run_in_executor where you can execute code in a different executor. You can pass None in order to execute your code in the default executor: ThreadPoolExecutor.

import asyncio
import time

@asyncio.coroutine
def clock():
    while True:
        print("Current time from asynchronous code: {}".format(int(time.time())))
        yield from asyncio.sleep(1)

def blocking():
    while True:
        print("Current time from blocking code: {}".format(int(time.time())))
        time.sleep(1)

def main():
    loop = asyncio.get_event_loop()
    loop.run_in_executor(None, blocking)
    asyncio.async(clock())
    loop.run_forever()

if __name__ == '__main__':
    main()

The output is:

Current time from blocking code: 1422265601
Current time from asynchronous code: 1422265601
Current time from blocking code: 1422265602
Current time from asynchronous code: 1422265602
Current time from blocking code: 1422265603

run_in_executor return a future and if an exception is raise your code is not stopped you need to check the future. A dummy sample code for stopping your code when something arrive:

import asyncio
import time
import concurrent

@asyncio.coroutine
def clock():
    while True:
        print("Current time from asynchronous code: {}".format(int(time.time())))
        yield from asyncio.sleep(1)

def blocking():
    while True:
        print("Current time from blocking code: {}".format(int(time.time())))
        time.sleep(1)
        raise Exception("Test")

def main():
    loop = asyncio.get_event_loop()
    block = loop.run_in_executor(None, blocking)
    async = asyncio.async(clock())
    loop.run_until_complete(asyncio.wait([block, async], return_when=concurrent.futures.FIRST_COMPLETED))
    print(block.exception())

if __name__ == '__main__':
    main()

Premier jour avec GO

Afin d’améliorer ma culture de développeur, j’ai décidé d’apprendre le GO, qu’on voit de plus en plus pour des backend demandant de la performance.

Pour comprendre mon avis, il faut savoir que j’ai un profil de développeur backend pour des startups. Je code en Ruby (y compris avec EventMachine) au travail depuis plusieurs années, dans mes loisirs je fais du Python. J’ai pas mal joué avec Node.js y a un an, mais je n’étais totalement satisfait par l’aspect déploiement et la stabilité. J’ai aussi un bon background en C grâce à mes études à EPITECH.

Voilà donc mes premiers retours après une journée de GO. J’ai choisi d’écrire pour faire mes tests une application très simple qui va vérifier le DNS d’un grand nombre de domaines en même temps.

Je retrouve le slogan de Python “fourni avec les piles”. En effet de base les développeurs de GO fournissent pas mal d’outils de base pour la doc, les tests, le formatage du code, gestion des dépendances…

La syntaxe

La syntaxe contient quelques bizarreries pour nos esprits formatés, mais rien d’insurmontable.

Par exemple la déclaration d’une fonction:

func TestDomain(domain string) bool {
}

Cela nous donne une fonction TestDomain qui prend en argument un domain de type string et on retourne un bool.

Autre point qui parait bizarre au premier abord:

a := 1
a = 2

L’opérateur := est un raccourci pour déclarer et affecter une variable. En effet le compilateur ne vous laisse pas utiliser une variable non déclarée.

On pourrait l’écrire ainsi:

var a;
a = 1
a = 2

Point très positif pour moi, une commande gofmt est fournie avec le langage. Cela va reformater votre code selon les normes en vigueur dans le monde du GO. Cela coupe court au débat sur l’indentation, la place des parenthèses… Et on retrouve donc le confort de Python où deux codes sont formatés de la même manière.

VIM

Pas de problème de ce côté là j’ai installé VIM-GO qui fait le job:

  • coloration syntaxique
  • vérification des erreurs de syntaxe
  • reformatage du code lorsqu’on sauvegarde avec gofmt

 Gestion de modules

Fournis de base avec le système vous pouvez téléchargez des modules (souvent hébergé sur Github).

go get github.com/noplay/madep

Dans votre code vous pouvez ensuite référencer le code en utilisant le même nom:

package main

import (
	"github.com/noplay/madep"
	"github.com/miekg/dns"
)

Je trouve cela assez pratique, car on retrouve très facilement le site d’où vient un module.

La documentation

Pour le moment tous les modules que j’ai utilisés étaient bien documentés avec généralement un readme qui explique bien l’utilisation du module.

Une commande godoc vous permet d’afficher la documentation et via:

godoc -http=:6060

Vous avez un serveur de documentation un local.

Les Goroutines

L’un des éléments qui rend le GO pratique pour la programmation concurrente est le concept des Goroutines. En effet pour lancer un traitement de tâches de fond il suffit de rajouté le mot-clef go devant l’appel. La fonction sera lancée en tâche de fond et votre code continuera son exécution.

go long_traitement()

C’est une sorte de thread léger.

Les channels

Pouvoir lancer des tâches de fond c’est bien, mais encore faut il communiquer avec. C’est là qu’entre en oeuvre le concept de channels. Basiquement c’est un tube dans lequel on écrit d’un côté et on a une lecture bloquante de l’autre côté.

messages := make(chan string)

go func() { messages <- "hello" }()

msg := <-messages
fmt.Println(msg)

C’est un système simple et qui s’avère efficace à l’usage.

Ce qu’il me reste à voir

Je n’ai pas encore testé le déploiement et c’est un point qui peut devenir compliqué sous Mac OS vu que cela implique de la cross compilation. Il y a aussi un framework de test fourni que je n’ai pas regardé.

Conclusion

Pour le moment j’ai une très bonne première impression sur GO. Le langage semble robuste et relativement simple de prise en main. Les concepts pour la programmation concurrente sont faciles à mettre en oeuvre. Par contre, cela ne remplacera par Ruby ou Python qui ont du sucre syntaxique qui rend certaines taches plus agréables (l’intégration des regex dans ruby par exemple).

Le fait de déployer juste un binaire en production me semble une bonne idée quand on voit les cauchemars dans lesquels on tombe vite lorsqu’on déploie du Ruby, du Python ou du Node.

La syntaxe me plait beaucoup plus que celle du C++ qui offre trop de possibilités ce qui fait qu’on se retrouve avec autant de C++ que d’endroit où l’on fait du C++.

Nouveau blog

Voilà j’ai enfin pris le temps de troquer mon vieux blog sous SPIP avec un nouveau sous Jekyll. C’est l’occasion d’un gros redesign.

On oublie donc le vieux squelette:

Pour un thème dérivé du thème HMFAYSAL OMEGA avec un look plus moderne. Et a moi le plaisir de blogguer en statique.

J’ai surement cassé plein de truc au passage lors de la migration et je vais réparer au et à mesure.