WorldDomination.be blog

Idée d'une plateforme d'entre aide pour étudiants

2012-05-02T08:36:00Z

Ceci est un texte que j'ai écris pour formaliser mes idées sur comment nous pourrions essayer d'utiliser aux mieux les formidables possibilités d'Internet pour favoriser l'entre aide entre étudiants.

Un brouillon de ce texte a déjà pas mal circulé et ces idées se sont concrétisé début 2011.

Préface

Il y a quelques années, j'ai été délégué cours dans une organisation étudiante où mon but était de coordonner l'échange et la vente de copie de packs de résumés/anciennes questions d'examens/notes de cours.

Depuis, l'idée d'améliorer l'entre aide entre étudiant est souvent revenue dans mon esprit. Le statut quo étant assez décevant: le seul nouvel usage qui a été créé avec l'apparition d'Internet a été de scanner tous ces documents et de les mettre en lignes pour plus facilement les échanger, ce qui est bien mais vraiment limité. À côté de ça, écrire un résumé de cours ou tout autre document similaire reste un travail laborieux et chronophage. Résultat, ces documents sont rares, souvent en partie dépassés et très rarement améliorés.

Avec Internet, la plateforme par excellence pour favoriser l'entre aide et la collaboration sur des projets d'intérêt commun, ce constat est particulièrement décevant.

En parallèle, j'ai été investi dans plusieurs organisations dont les membres se voyant très peu irl et qui par conséquent travaillaient quasiment exclusivement avec des outils leur permettant de faire cela via Internet. Par exemple avec des etherpad -lite, des wikis ou encore co-ment.

C'est principalement de l'immersion dans ce monde que vient mon inspiration.

Concernant notre problème, une chose dont je suis relativement sûr c'est que l'innovation doit venir de nous, les étudiants. Le corps académique est globalement malheureusement trop peu réactif et intéressé par la question et nous sommes plus à mène de comprendre les problèmes que nous rencontrons que les académiques.

Remarque: il y a quand même des innovations venant d'eux, les exemples récents les plus impressionnants sont les cours en ligne de Stanford (à l'initiation de 2 professeurs las des cours théoriques de 2h) qui s'est transformé en Coursera et à la réaction du MIT s'appelant MItx (que j'ai bien moins aimé mais bien moins testé, j'ai l'impression qu'on y perd tout le côté humain du petit professeur tout motivé qui aime tellement son cours qu'il veut le transmettre au monde entier).

Qu'est-ce qui peut être amélioré ?

Question primordiale, quelle direction voulons, voire pouvons nous prendre ? Notre système éducatif est structuré de manière fondamentalement individualiste, même les rares projets de groupe se font presque "pour soit", cela ne nous laisse pas une grande marge de manœuvre. Donc, qu'est-ce que nous faisons tous en tant qu'étudiants, qui est partageable et dont nous ne partageons pas ou pas encore très bien le fruit ? S'échanger les réponses aux questions d'examens pendant un examen n'est pas vraiment ce qui nous intéresse ici.

En fait, la réponse est assez simple et est juste un niveau d'abstraction au dessus de ce que nous faisons déjà avec l'échange de packs de cours: il s'agit du déchiffrement des cours.

Chaque étudiant passe un temps non négligeable à chercher à comprendre ce que signifie son cours, la qualité du matériel à disposition étant variable, les principes pas toujours immédiats, c'est une des principales activités de l'étudiant.

Comment l'améliorer ?

La solution est en fait assez simple et inspirée directement d'un mécanisme utilisé par le djangobook (il n'est pas le seul à le faire):

Page d'aide pour leur système de commentaires.

Le principe est de découper le livre par paragraphe et de permettre aux utilisateurs d'y rajouter des commentaires pour partager leurs questions/remarques/découvertes.

Donc l'idée serait tout simplement, dans un premier temps, d'offrir aux étudiants un service leur permettant d'appliquer ce même principe à tous les documents en rapport avec leurs cours et ceux de leur choix.

Pour insister, cela concerne en autre les cours disponibles, les notes de cours, les anciens examens, les exercices disponibles, les résumés fait par les étudiants et tout ce que j'ai oublié.

De cette manière, le travail d'analyse et de compréhension que chaque étudiant faisait seul (ou en comité réduit) pourra désormais être partagé et l'entre aide grandement facilité.

Facilité d'adaptation pour les utilisateurs

Ce type d'interface assez récent n'est pas forcement intuitif pour les étudiants qui ne sont pas forcement tous des habitués de l'informatique. Après avoir discuté avec certains d'entre eux, ils m'ont dit qu'un type de site très familier pour eux étaient les forums (type phpbb). L'idée est donc que chaque topics de commentaires associés à chaque paragraphe soit en fait un topic dans un forum correspondant, de cette manière ils ne seront pas trop déboussolés ce qui facilitera l'adoption d'un outil de ce genre.

Allons plus loin

Ceci est un bon début, être capable de partager sur chaque paragraphe permet déjà de reproduire ce qui se faisait déjà en petit comité à une plus grande échelle. Mais s'arrêter ici serait dommage. En effet, pour les étudiants qui viennent après, parcourir des topics de discussion à la recherche d'une réponse à une hypothétique question éclaté en plusieurs réponses d'autres étudiants n'est pas des plus efficace. C'est déjà le cas sur candiulb par exemple.

Une façon relativement simple et efficace de résoudre ce problème est d'offrir aux étudiants une page de type wiki (avec syntaxe scientifique à disposition, inclusion d'images, historique etc ...) pour chaque paragraphe. De cette manière les étudiants pourront coucher le fruit de leurs échanges et réflexions de manière formalisé et claire.

De cette manière, tous ces documents qui étaient morts, peuvent désormais trouver une nouvelle vie, être complété, redevenir d'actualité et être une ressource historique pour les futures promotions.

En plus d'un outil d'échanges nous obtenons un outil d'amélioration, voir de (re-)création.

On peut même imaginer à très long terme voir le document entièrement disparaitre et être remplacé uniquement par ces nouvelles pages wiki et devenir ainsi totalement « vivant ».

Autres fonctionnalités intéressante

Une fonctionnalité tout à fait désirable serait la possibilité de générer un nouveau document compilant les paragraphes du documents original entrecoupés des commentaires et/ou pages wiki créées par les étudiants en vu de pouvoir l'imprimer.

Interactions avec le corps académique

Une fois le projet bien lancé et la plateforme tournant avec un nombre non négligeable d'étudiants actifs, une nouvelle étape peut être franchie. Cela consiste à aller voir les professeurs sensibles à ce type de projets et de leur dire: « voici une plateforme de feedback instantané pour vos cours qui vous permet de voir où vos étudiants sont bloqués, ce qu'ils ont du mal à comprendre, comment les aider et où améliorer votre cours ».

Bien sûr chaque professeurs est différent et il est tout à fait possible que certains voient cela d'un mauvais œil mais je pense que si le concept accroche chez les étudiants et qu'une masse critique de professeurs est atteinte il y aura un effet de basculement et que ce genre d'outils et de méthodes deviendront progressivement standards.

Implémentation

Ce projet peut sembler conséquent, il n'est en tout cas pas petit, mais je pense qu'avec un framework web moderne une très grosse partie du travail a déjà été faite et qu'il y a "juste" à assembler les différents morceaux ensembles et à se concentrer sur une bonne interface (très important).

Je vais prendre l'exemple de django vu que c'est celui que je connais le mieux:

Il suffit juste d'assembler les pièces pour avoir rapidement un prototype utilisable mais à mon avis le travail d'interface sera quant à lui bien plus conséquent.

Remarque: étant donné la nature des PDF, il est bien plus possible que le découpage se fasse par pages et non par paragraphes, au moins dans un premier temps. Pour les autres formats ils sont généralement structurés et ce sera donc bien plus facile. Ils sont aussi malheureusement plus rare.

Projet en cours

Ayant parlé de cette idée à gauche à droite, un bon pote avec qui je suis toujours d'accord sur le fond mais jamais sur la forme a décidé d'en faire son projet d'année.

Bien entendu le projet est libre (agplv3) mais assez fort lié à notre université (l'ULB). Le code se trouve ici.

How I fell in love with debugging tools for python

2012-03-16T03:34:48Z

Until recently, I've never got to really use pdb (python debugger) nor to like it. It didn't bring me anything, broke my mental workflow, was annoying to use and print statement always seems more efficients.

Then I discovered:

ipython --pdb script.py

And my world changed.

What does it do? It simply drop you into ipython if your script crash at the exception raising point. So. Damn. Simple. and effective. Awesome shell and you don't have to modify your code and/or remember how the hell to set a breakpoint with pdb. You just have to change "python" into "ipython --pdb".

(If you don't know ipython, download it, install it and use it instead of the default python for your python shell sessions, it's a day and night chance, just the autocompletion on tab is a killer feature).

This damn simple trick has been life changing for me. Just test it and there is great chances that you'll fall in love.

Ipdb

Sometime you'll still need to use a pdb-like approach. But pdb seems so arid next to ipython. Lucky we are, someone got the awesome idea to "merge" ipython and pdb!

I present you: ipdb

Just drop:

import ipdb import set_trace; set_trace()

where you want in your code, just like with pdb.

And for lazy Vim users with as good memory than mine:

command! Ipdb norm! Ofrom ipdb import set_trace; set_trace()

(Then just use the command :Ipdb and this will put the desired line on the line above your cursor).

I want this in django!

Lucky you are again! This is nearly as awesome as the previous trick (but not as powerful as an ipython shell but still awesome).

Just install django-extensions and werkzeug (pip install django-extensions werkzeug) then run:

python manage.py runserver_plus

And on an exception you'll be dropped on werkzeug debugging page that allow you to browse you code and, way more awesome, to launch a python console right there in your browser on every part of the stack!

This is also very life changing.

Make sure to look at the others features of django-extensions, some are of it are very cool.

Bonus

Simple bash aliases that make me win so much time and make virtualenv way more enjoyable to use:

alias mkve="virtualenv --no-site-packages --distribute ve; source ve/bin/activate" alias ve="source ve/bin/activate"

How to backup tweets from a series of twitters accounts

2012-03-01T19:20:37Z

I've recently setuped a git repository that contains the backuped tweets from a series of twitters accounts related to freesoftware, net neutrality and opendata.

Following a demand from Hugo Roy that wanted to do the same, here is a README that explains how to do this.

Redirections finally done

2012-01-20T00:55:55Z

Thanks to my good old friend procrastination, I was finally forced to do something way more boring than configuring url redirections to avoid broken urls from my older blog engine, hurray \o/

I'll check out the 404 from the logs from time to time to see if something is missing.

On a side node, it's always a bit chilling to go through the list of 404 and to see all the urls tried by scripts to crack random websites.

Release of MyTemplates 0.2

2011-11-18T04:15:06Z

The new version of MyTemplates is out!

The new feature of this release is to allow mtpl to run python scripts that will be responsible for create a more complex template that just a single texte file.

For reminder MyTemplates is a tool to manage a collection of templates files for coding that use git. The current templates repository host for the moment licences templates, some scripts to write irc bots, some templates for python (ie: setup.py) and more. Feel free to submit new content (send a pull request!).

Links and source.

You can also find it on pypi.

Version 0.2 of the PipeToolKit

2011-11-02T02:29:12Z

I'm proud to announce you a new release of the PipeToolKit.

The PipeToolKit is a collection of small utilities to play with unix pipes and write new one. I use it a lot with ii, feedstail and other utilities to build highly customizable irc bots.

I've also add some documentation on the python template class I use to build those utils in the case you want to code your owns.

Installation:

pip install pipetk

The pypi page.

Code!

Changelog

pdetinyfy now works for urls inside a string
new script: puniqrt to try to eliminate duplications for tweets
new template to build pipes utils that works on the urls of a string
add premoveurls as en example script for the new template
new script: pcleanurls to remove useless tracking pieces of urls (like utm_* stuff)
various bug fixs
add doc on how to write new pipe utils

First release of mtpl

2011-11-01T02:25:24Z

I'm proud to announce you the first release of mtpl (as in MyTemplates). This is a very simple program that aim to manage a collection of various templates files for scripts/licencing/code.

Bored of constantly copypasting the gpl/setup.py/cool shell script from the web/your matchin project? Mtpl aim to fix this by providing a simple and straightforward cli interface. Git is used for storing files.

All the details can be found on the pypi page.

Installation

pip install mtpl

All old content up again \o/

2011-10-30T16:05:34Z

Yay \o/

As the title say it, I've reupload everything and I've corrected the broken links to match this new blog engine.

Now I just need to do the correct redirections because cool urls doesn't change.

Re-uploading of old content

2011-10-06T03:03:58Z

Small post to talk about my progress in reuploading the content of my old blog.

I've reuploading all my old blog posts (minus some crap ones) and a part of the static pages. There is still work to do but most of the more importants parts are here.

Hello World!

2011-09-16T01:44:43Z

Hello world again. After too much down time I'm recreating this website. I've moved to the hyde static website generator. It's pretty neat and simple and it uses the django template engine.

I'm going to re-up progressively all the previous content and try to restore all urls (cool urls don't change!) but I'm quite busy for the moment so this will be incremental.

Thanks again to Hobbestigrou for his help and the hosting.

Cheer,

FeedsTail 0.2 - python 2.5 compatibility

2011-04-28T06:58:20Z

A small post to said that Romain and I just released a new version of FeedsTail that is compatible with python 2.5.

Note that the formating format is the one of python 2.5. So you'll have to do something like this:

feedstail -u http://reddit.com/.rss -f "%(title)s - %(link)s"

Except additional releases in the next days.

First release of FeedsTail

2011-04-26T12:50:10Z

Ohai, I'm proud to announce you the first release of FeedsTail.

The aim of this program is to read and display a RSS/Atom feed and to display it like a tail -f would do it on a file. This behavior allow a lot of stream scripting.

For those who already know it, Feedstail is a python clone of rsstail.

The main differences are:

a much more smaller code base (thanks to python) that allow it to be much more easier to hack
a much more powerful output formatting capacity (but more complicated to use, it plays with the .format function of python)
the ability to choose any element of the feed as the unique key (therefore avoid displaying an old item only because the title has changed)

You can find all the technical details and how to install it on the pypi page.

Thanks to the excellent feedpaser library, Feedstail is already very stable. It won't crash on disconnections or XML errors. If the feed structure doesn't change and your formating string (the -f option) doesn't rely on elements that may not be presents you can expect feedstail to run safely for severals days. But it's still the first release so don't hesitate to send bug report!

Feedstail is coded by Romain Gauthier on my demand to solve some problems for La Quadrature du Net. Thanks to him!

HolyCurse 0.1

2011-04-17T00:06:15Z

Ohai,

I'm proud to announce the first release of HolyCurse, a ncurses interface to HolyGrail my GTD lib.

Traditionnal screenshot:

Being a first release, not all the feature of holygrail.html are supported. This doesn't prevent me from using it daily. Here is a list of the features:

ncurse interface with a bunch of vim spirit
include documentation for all the commands, press "?"
support missions (todos), realms (contexts) and quests (projects) in a minimalist way
missions can be: created in various ways, tickled (limited options), deleted, renamed, due (limited options), toggled, completed and recreated, transform into a new quest, assigned to a quest and changed of realm
when a mission include in a quest is completed, the user is asked to enter the next mission description
display a "|" for each week has passed since the creation of a mission
realms can be: created, hide, renamed and have their positions changed
display the super main view
display a realm view
is full of data love and magic

Hope you'll loved hit. Don't hesitate to send me feedback/bugs reports.

HolyGrail 0.2 Perceval

2011-04-06T16:55:42Z

I'm proud to announce you the release of the version 0.2 of HolyGrail, my next actions list management library.

You can downloaded it here or via pypi:

sudo easy_install -U holyview

Since this new version introduce modification in the API and therefore possible incompatibility with previous code design for the previous version of the lib, I've decide to move from 0.1.* to 0.2.*.

Changelog:

API change: now every list_* methods return a generator, not a list. This increase the performances.
API change: last_completed_missions return only 5 missions by default, an argument can increase this number
fix a bug with quest and realm "get_missions" method that won't return any missions if the quest/realm is hidden

For a short summary, HolyGrail is a library designed to manage a list of next actions (a todo list) in the GTD's way. I've chosen to write a documented library to offer everyone the possibility to write it's own interface instead of imposing mine. The organisation of the actions are in the GTD's way: todos are group in contexts (realms) and can me member of a project (quest).

I'm planning to release shortly (lulz) an ncurse interface for HolyGrail. I just want to finish some things before (having a browsable help).

More informations

An epurate ebook (epub) reader for your pc

2011-03-20T01:16:17Z

From time to time I like to be able to read e-books (epub/mobi) on my pc. I wasn't satisfied by fbreader. The interface and customisations possibility are really cools, but the rendering kinda sucks (and doesn't works well for <span> tags that contain source code, this make unreadable most of my home made programming e-books).

After some research I've found lucidor. Doesn't look fantastic from a first view but the rendering is good.

Problem: I wanted to have a dark background and a grey font and the configuration options doesn't offer that possibility. Solution: use the power of dirty hack and voilà, here is the result:

And after some customisations (using the menu from the right mouse button):

And the diffs for my dirty hack. On the file: /usr/share/lucidor/chrome/content/xhtml.css:

4c4, 6
<     background-color: #ffffff;
---
>     background-color: #000000;
>     color: #BBBBBB;
14c16
< /*
---
>
16c18
<     background-color: #ffffff;
---
>     background-color: #000000;
18c20
< */
---
>
20a23
>     background-color: #000000;

And on /usr/share/lucidor/chrome/content/ordbrand.css:

7c7, 8
< background-color: #ffffff !important;
---
> background-color: #000000 !important;

This still isn't perfect: I didn't managed to find a way to add "j" and "k" for scrolling.

Also, I've made a simple mobi/epub version of the DjangoBook that you can find here (epub version). It doesn't include images (it was boring to do).

Small dirty script to transform the core of a web page into a .mobi

2011-03-12T15:57:49Z

I'm the owner of a Kindle. This little (non free :/) piece of hardware has quite changed my life. I now want to read everything on it. Especially long web articles. So, I've written a small script that extract the core information of a web page then transform the result into a mobipocket file.

This script combine two tools: decruft (a python implementation of the readability core algorithm) and ebook-convert, a tool supplied by calibre (it's in the pkg "calibre-bin"). I glued everything with some dirty bash, and voilà.

The result code is quite horrible (and buggy in some places) but is good enough for my needs. Despise this dirty aspect I release it anyway, maybe it will be useful for someone or, even better, maybe someone will code a better version.

#!/bin/bash

mobify()
{
    # decruft don't create correct headers :(
    # also grab the title of the webpage using python
    echo "<html><head><title>$(python -c "from mechanize import Browser;
        b = Browser(); b.open('$1'); print b.title()")</title></head></body>" > .tmp.html
    decruft.py -u $1 >> .tmp.html
    echo "</body></html>" >> .tmp.html
    # remove some useless stuff that decruft don't remove
    sed -i 's/<p [^>]\\+>/<p>/g' .tmp.html

    # download images to includes them in the mobi file (ebook-convert do that automatically)
    # (I'm pretty sure wget can do this in a much better way)
    # for every images
    for i in $(grep "<img" .tmp.html | sed 's/.*src="\$[^"]\\+\$".*/\\1/g' | sort | uniq);
    do
        # if I'm a direct url
        if [ $(python -c "print '$i'.startswith('http://')") == "True" ]
        then
            wget "$i"
        else
            # add the beginning of the website name to create a complete url
            # I'm pretty sure this part is buggy, the $() probably inject caracters interpreted by sed
            wget $(echo "$i" | sed "s/^/$(echo "$1" | sed 's#http://##' | sed 's#/*##' )/")
        fi
    done
    # change the url in the <img src="" /> to point it to the current folder
    sed -i 's/src="[^"]*\\//src="/g' .tmp.html
    ebook-convert .tmp.html mobi/$2.mobi
}

# arg parsing
if [ $1 ];
then
if [ $2 ];
then
    if [ -e mobi/$1.mobi ];
    then
        if [ $3 ]
        then
            if [ $3 == "force" ]
            then
                mobify $1 $2
            else
                echo 'add "force" as last args'
            fi
        else
            echo 'add "force" as last args'
        fi
    else
        mobify $1 $2
    fi
else
    echo "Usage: <url> <filename (without extension)> [force]"
fi
fi

Release: HolyView version 0.1

2011-02-24T09:48:29Z

I'm proud to announce you the first release of HolyView.

HolyView is a ncurse tool design for long term organisation. It's purpose is to help you chose what to do now to be the most effective in the long term. It is based on a time management approach describe by Stephen Covey. It's interface is sort of vim-ish.

The principle is simple: take a set of things or sector in which you want to invest yourself (code project, studies, work, saving the world, building a huge lazor, family...). Sort them by importance, then sort them by urgency. Now you can classify them in 4 categories: urgent and import, import, urgent, non-urgent and non-important. In an ideal world you should only focus on important things. Also on important and urgent things, but the purpose on focusing on important things is to complete them before they became urgent. The two others categories should be ignored.

HolyView specific concept: you can add "points" to a thing. I do this when I have worked on this thing. The date a point is add is stored, this will allow the creation of monitoring graphics will be easy.

You can also mark as completed a thing, this will hide it from the list and won't show it by default.

More details on this time management method.

Screenshots:

Installation: sudo python setup.py install

HolyView is also available on pypi: sudo easy_install holyview

Dependencies: louie and urwid (at least 0.9.9)

Data are stored using cPickle.

.mobi version of Learn You Haskell for Great Good!

2010-12-27T16:11:07Z

I’ve just created a .mobi version (for kindle) of Learn You Haskell for Great Good! book, you can find all the details here.

How to build your own statusnet/twitter client with an irc bot + a way to pipe a RSS feed to a status.net/twitter account

2010-12-04T18:28:17Z

I’ve just finished writing a guide on how to build your own status.net/twitter client using only few lines of bash.

Here it is.

Bonus: include an easy way to pipe a RSS feed to a microblogging account.

Readabilty, make the web readable again

2010-10-09T16:18:18Z

I've just discover readability, a bookmarklet that clean a web page to only display the text in a very lisible format. I was something I was looking since a long time.

Here is a example with my configuration:

Before

After

To install it, you can simply follow the instructions in the (in flash, meh.) video on the readability website. But, if you are using vimperator, here is simple manipulation to integrate it:

Go into your ~/.vimperator/plugin/ (or create it if you don't have it), then:

wget http://github.com/ervandew/vimfiles/raw/master/vimperator/plugin/readability.js

(Found here)

Open the script, read a little bit to know the options you want and add them into your ~/.vimperatorrc.

Here are mines:

javascript readabilityStyle = "apertura"
javascript readabilitySize = "large"
javascript readabilityMargin = "wide"
javascript readabilityBackground = "#000"
javascript readabilityColor = "#aaa"

To finish, restart firefox.

The command is :readability. You can also add a map:

:map v :readability<cr>

(v, isn't used by vimperator)

I was looking to recreate my terminal appearance. I found it pleasant for my eyes.

I'm happy to see that readability doesn't nearly change anything on my website. It nearly create the css I would have done if I wasn't so lazy.

Hope you'll enjoy this script.

First release of HolyGrail, 0.1 Galahad

2010-10-08T11:49:58Z

Ohai,

I am proud to announce you the first release of HolyGrail ! This is the version 0.1 Galahad (knights of the round table !).

But, what is HolyGrail ? It’s an hight level lib to manage the holy quest of your life ! In other words, it’s an hight level lib to manage a next actions list (organisation, todo etc…) in the sens of the GTD. This way you can easily build your own interface, switch from different interface and write scripts.

This first release manage:

missions (todos) with description, tickler, due date, wait for previous missions, tags, creation and completion date and other.
quests (projects) with description, completion, creation/completion date, due date, hide possibility and other. A quest is composed of missions.
realms (contexts) with description, creation date, hide possibility, position organisation and other. A realms is a group of missions.

For a more complete description of HolyGrail (with links to documentations, code, pypi etc…) go here.

You can install HolyGrail via pypi:

easy_install holygrail

Oh noes, the Internet invades my frat's local!

2010-10-03T01:24:37Z

We have just finished to repaint our fraternity local. Here are some of the results:

My last work.

From a friend of mine, here also made the initial drawing.

This one is a bit old, by me and a friend.

Come to drink a beer with us!

More pics

Eliminate duplications through a bash pipe

2010-09-27T21:16:44Z

Problem:
I receive data from a continuous stream (a tail -f or rsstail output for example). I want to remove duplications. | sort | uniq won't work since it's a non-ending stream (and I don't want to sort them). So much drama.

Solution: Launch Vim and code.

Result, tadaaa:

#!/usr/bin/python

import sys

anti_doublons = set()
a = sys.stdin.readline()
while a:
    if a not in anti_doublons:
        sys.stdout.write(a)
        sys.stdout.flush()
        anti_doublons.add(a)
    a = sys.stdin.readline()

(I will create a pipe/stream toolkit to distribute all this kind of stuff to play with bash pipe in the next days).

Some data pr0n about the Gallo's report and the wd12

2010-09-25T08:26:46Z

I’m becoming more and more addict to data pr0n threw time. My last victim is the Gallo report. It sadly have been adopt. It basically prepare the field in Europe for ACTA (wikipedia). Since the written declaration 12 against ACTA have just been adopt, I was interested in how much MEPs were schizophrenic enough the sign the wd12 and vote for the Gallo’s report.

Here is the first graphic. A comparison between Gallo’s report vote and the wd12 signatories, party oriented:

A more general one about the Gallo’s report vote (abstention aren’t showed):

And countries oriented graphics (abstention in grey):

If you want to made an analyse you can take a look at wd12 graphics and wd29 (against internet) graphics.

A detailed comparison list between wd12 and Gallo’s report can be found here but it is not intent to be spread (understand: this is quick’n dirty work).

Your own rss-irc chan

2010-09-05T00:45:33Z

This is my new invention to lose time (I've made an expertise about that).

The principle is simple: you have an irc chan with a bot and a simple command !rss. You pass the uri of a rss and it will be now monitored and display on this chan. I've made this to have a news oriented irc chan.

You'll need ii and rsstail. Set up the ii to put it on an irc chan (I've personally set up my own irc server).

Here is a script to launch and relaunch your ii:

#!/bin/bash

while true
do
    (sleep 7; echo "/j #mychan" > irc/irc.server.net/in) &
    ./ii \\
        -i "irc" \\
        -s "irc.server.net" \\
        -p "6667" \\
        -n "mybotname" \\
        -f "mybotname"
done

Once everything is in place here is the (dirty) script to add the !rss command.
But before, create a .while_cond file in the same directory where you'll place this script. This will help you kill a rsstail instance. Since this script launch the rsstail instance in a while true loop to make sure it won't be down, you have to use this mecanism to avoid the loop to start again. To kill a rsstail you have to write "false" in the .while_cond file then kill the chosen rsstail (don't forget to change .while_cond back after that).

#!/bin/bash

CHAN="#mychan"

# no line containing the messages of the bot
tail -n 0 -f path/to/$CHAN/out | grep -v --line-buffered "<mybotname>" | grep --line-buffered "\\>" | while read -r line
do
    printf '%s\\n' "$line"
    message_text=`printf '%s\\n' "$line" | sed 's/.\\+> //'`
    case "$message_text" in
        !debug)
          echo "I HAZ NO BUGZ" >> path/to/$CHAN/in ;;
    !rss\\ *)
        temp=`printf '%s\\n' "$message_text" | sed 's/!rss \\?//'`
        echo "[new RSS] $temp"
        while true; do ./rsstail -u "$temp" -l -P -z -N -n 1 -i 60 >> path/to/$CHAN/in; if [ $(cat .while_cond) = "false" ]; then break; fi; done &
            ;;
    esac
done

One other detail: I have remove the carriage return between the title of a rss item and the link by hacking rsstail source code. This is somewhere at line 436. Yes, this is dirty but you should be accustomed now.

I hope you'll lose plenty of time with this script.

Nerd pastime

2010-09-02T21:38:39Z

dots

nerd

This one is made from 1000 (careful, 4.2mo, prefer download) pic. 100 for this one.

Then, looking for way to make this look funnier I discover that cooler graphs already exist.

Script (remove the color stuff, will display as on wikipedia).

An experiment.

This is the next xkcd I will reproduce.

pytestator, un script vim pour gérer ses tests unitaires plus facilement

2010-07-16T19:41:14Z

J’ai (enfin) releasé un petit script vim pour rendre plus agréable l’utilisations de tests untaires pour python dans vim.

Le principe est assez simple, ce script vous introduit plusieurs nouveaux raccourcis dont voici les deux plus intéressants:

, s qui vous fais passer du fichier de tests au fichier testé et vice versa (s pour swap)
, tr qui lance le fichier de tests correspondant au fichier que vous êtes en train d’éditer, que vous soyez dans ce fichier ou dans le fichier de test (tr pour test run)

La page du script avec un peu plus d’informations et du mauvais anglais: http://www.vim.org/scripts/script.php?script_id=3151

Sinon des mappings que j’aime bien pour écrire mes tests unitaires:

imap ,ar self.assertRaises()<left>
imap ,ae self.assertEqual()<left>
imap ,at self.assertTrue()<left>
imap ,af self.assertFalse()<left>

Mes maps git pour vim

2010-06-26T01:32:10Z

Un poste rapide pour vous donner mes maping pour git dans vim. J’ai beau avoir regardé tous les plugins vim pour git, aucun ne m’a plus, je me suis donc contenté de faire plein de maps pour pouvoir utiliser git dans vim et ce le plus rapidement possible.

Le principe est très simple et surtout facile à retenir: les maps commencent tous par “, ” (comme tous mes maps ou presque) puis par “g” (comme git), après je rajoute une lettre qui est le début de la commande et je la mets parfois en majuscule quand c’est la même commande avec des options différentes. C’est tout bête mais ça permet de ne taper que 3 char pour faire n’importe quelle commande (qui est beaucoup plus longue à écrire), je me retrouve même à ouvrir vim pour utiliser git maintenant -_-“

map , ga :!git add -p<cr>
map , gA :!git add %<cr>
map , gf :!git add
map , gs :!git status<cr>
map , gc :!git commit -m “”<left>
map , gC :!git add %<cr>:!git commit -m “”<left>
map , gd :!git diff<cr>
map , gD :!git diff —cached<cr>
map , gp :!git push<cr>
map , gP :!git pull<cr>
map , gb :!git branch<cr>
map , gB :!git branch
map , gh :!git checkout
map , gi :!git init<cr>
map , gt :!tig<cr>
map , gl :!git log<cr>

ULR, url list reader ou mon viewer pour newsbeuter

2010-05-18T04:44:21Z

MAJ: j'ai déjà reçu mon premier patch (gloire) par taziden qui permet d'ajouter l'url courante dans un fichier "bookmarks" (touche B) donc le code qui suit n'est plus à jours.

Situation: j'utilise newsbeuter pour lire mes RSS. C'est véritablement le meilleur lecteur de RSS sur lequel j'ai pu mettre la main, en plus il est en console. Sauf que, pour une fois la console me fait chier. En effet je lis plein de blog bayday et autre webcomics idiot et tout ce joli petit tointoin est rempli d'images ce qui ne fonctionne pas très bien en console. Surtout que j'ai une queryfeed avec des centaines d'éléments.

Dans l'ordre, voici les solutions qui s'offraient à moi:

utiliser la fonction intégré à newsbeuter pour ouvrir l'url dans mon naviguateur oueb. Ça va un moment, mais c'est lent et vraiment pas efficace.
histoire d'automatiser un peu le tout je me suis fait des macro super bourrin qui ouvre 10 20 30 40 80 120 élément dans mon browser. ça marche pas mal, sauf que Ça fait souvent péter firefox, faut attendre que tout est chargé, c'est pénible.

Puis finalement j'en ai eu marre et j'ai décidé de coder ma propre solution et voilà l'arrivé de ULR (vous remarquerez le subtile jeux de mot), un naviguateur web ultra minimaliste.

Le principe est simple: vous rajoutez des urls dans un fichier (ou lui passé en argument, il les rajoutera lui même). Puis vous le lancez le browser qui naviguera dans cette liste d'urls.

C'est du python, ça utilise webkit (le machin pour utiliser gecko était vraiment pourri en comparaison), c'est minimaliste, sans interface, juste des raccourcis clavier. J'aurais pu faire ça avec UZBL mais je n'ai pas eu le courage de chercher à comprendre comment le faire même si cela ne doit pas être bien difficile et puis quand je vois que cela tien sur moins de 200 lignes de python.

Un jouli screenshot:

Et parce que c'est toujours pratique pour l'utilisation, les raccourcis:

esc/q: quitter sans modifier la liste
n/espace: passe à l'url suivante (espace fait baisser l'écran aussi, j'ai eu la flemme de corriger ce bug)
r: fait un refresh de la page courante
s: sauve l'avancement dans la liste des urls (en gros supprime du fichier urls les urls déjà vu)
S: pareil puis quitte
y: copie l'url courante dans le clipboard de X (il faut avoir xclip installé)
f: envoie l'url vers firefox (il faut bien entendu qu'il soit installé)

Pour choper le code, un petit git clone git://git.worlddomination.be/python/ulr.git

EDIT: Le code qui suit ne correspond plus au master.

Et parce qu'il n'est pas très long mais bien dégeux (je n'avais aucun intérêt à le faire propre), voici le code:

#!/usr/bin/python
# -*- coding:Utf-8 -*-

import gtk
import os
import sys

import webkit
import gobject

class Browser:
    def delete_event(self, widget, event, data=None):
        return False

    def destroy(self, widget, data=None):
        gtk.main_quit()

    def open_list(self):
        self.urls = open("urls", "r").readlines()
        if len(self.urls) == 0:
            print "List empty, fill list before launching"
            sys.exit(0)
        print len(self.urls), self.urls

    def __init__(self):
        gobject.threads_init()
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_resizable(True)
        self.window.connect("delete_event", self.delete_event)
        self.window.connect("destroy", self.destroy)
        self.window.connect("key-press-event", self.keyboard_cb)

        self.open_list()

        self.position = 0

        #webkit.WebView allows us to embed a webkit browser
        #it takes care of going backwards/fowards/reloading
        #it even handles flash
        self.web_view = webkit.WebView()
        self.web_view.open(self.urls[0][:-1])

        #entry bar for typing in and display URLs, when they type in a site
        #and hit enter the on_active function is called
        self.url_bar = gtk.Entry()
        self.url_bar.connect("activate", self.on_active)

        self.bar = gtk.Label()
        self.bar.set_single_line_mode(True)
        self.bar.set_text(self.urls[0][:-1] + "               " + "%i/%i" % (self.position + 1, len(self.urls)))

        #anytime a site is loaded the update_buttons will be called
        self.web_view.connect("load_committed", self.update_buttons)

        scroll_window = gtk.ScrolledWindow(None, None)
        scroll_window.add(self.web_view)

        vbox = gtk.VBox(False, 0)
        vbox.pack_start(self.bar, False, True, 0)
        vbox.add(scroll_window)

        self.window.add(vbox)
        self.window.show_all()

    def on_active(self, widge, data=None):
        '''When the user enters an address in the bar, we check to make
           sure they added the http://, if not we add it for them.  Once
           the url is correct, we just ask webkit to open that site.'''
        url = self.url_bar.get_text()
        try:
            url.index("://")
        except:
            url = "http://"+url
        self.url_bar.set_text(url)
        self.web_view.open(url)

    def go_back(self, widget, data=None):
        '''Webkit will remember the links and this will allow us to go
           backwards.'''
        self.web_view.go_back()

    def go_forward(self, widget, data=None):
        '''Webkit will remember the links and this will allow us to go
           forwards.'''
        self.web_view.go_forward()

    def refresh(self, widget, data=None):
        '''Simple makes webkit reload the current back.'''
        self.web_view.reload()

    def update_buttons(self, widget, data=None):
        '''Gets the current url entry and puts that into the url bar.
           It then checks to see if we can go back, if we can it makes the
           back button clickable.  Then it does the same for the foward
           button.'''
        self.url_bar.set_text( widget.get_main_frame().get_uri() )

    def main(self):
        gtk.main()

    def keyboard_cb(self, widget, event, data=None):
        #print "event:", event
        keyname = gtk.gdk.keyval_name(event.keyval)
        print keyname
        if keyname == "Escape" or keyname == "q":
            print "call deleting"
            self.destroy(widget)
        elif keyname == "space" or keyname == "n":
            print "next"
            self.next()
        elif keyname == "r" or keyname == "R":
            print "reload"
            self.refresh("widget")
        elif keyname == "b" or keyname == "p" or keyname == "Backspace":
            print "previous"
            self.previous()
        elif keyname == "s":
            print "saving"
            self.save()
        elif keyname == "S":
            print "saving"
            self.save()
            print "destroying"
            self.destroy("widget")
        elif keyname == "y":
            print "copy to clipboard"
            if os.system('echo -n "%s" | xclip -i' % self.web_view.get_main_frame().get_uri()):
                print "#fail"
        elif keyname == "f":
            print "go to firefox"
            if os.system("firefox %s" % self.web_view.get_main_frame().get_uri()):
                print "#fail"

    def save(self):
        urls = open("urls", "w")
        for i in self.urls[self.position + 1:]:
            urls.write(i)

    def next(self):
        print "was:", self.position
        if self.position < len(self.urls) - 1:
            print "go forwarf", self.position + 1
            self.position += 1
            print "loading:", self.urls[self.position][:-1]
            self.web_view.open(self.urls[self.position][:-1])
            self.bar.set_text(self.urls[self.position][:-1] + "               " + "%i/%i" % (self.position + 1, len(self.urls)))
        elif self.position == len(self.urls) - 1:
            print "show finish", self.position + 1
            data = '<html><head><title>Hello</title></head><body><center><h1>Finish</h1><h3>One more step forward and the browser will quit and empty the list</h3></center></body></html>'
            self.web_view.load_string(data, 'text/html', "utf-8", "about")
            self.position += 1

        else:
      sp;    print "end ? saving ? destroy"
            self.save()
            self.destroy("widget")

    def previous(self):
        print "was:", self.position
        if self.position > 0:
            print "go back", self.position - 1
            self.position -= 1
            self.web_view.open(self.urls[self.position][:-1])
            self.bar.set_text(self.urls[self.position][:-1] + "               " + "%i/%i" % (self.position + 1, len(self.urls)))
        elif self.position == 0:
            self.position -= 1
            print "show begin"
            data = '<html><head><title>Hello</title></head><body><center><h1>Begin</h1></center></body></html>'
            self.web_view.load_string(data, 'text/html', "utf-8", "about")

if __name__ == "__main__":
    if len(sys.argv) > 1:
        __dir__ = os.path.dirname(os.path.abspath(__file__))
        open(os.path.join(__dir__, "urls"), "a").write(sys.argv[1] + "\ ")
    else:
        browser = Browser()
        browser.main()

Remarque: rien ne vous empêche de combiner ULR avec rsstail ou n'importe quel autre script ou programme.

Feel free to send patchs

Pour le configurer dans newsbeur, rajouter le simplement en browser, cela ne le lancera mais rajoutera l'url dans la liste des urls à lire, puis pour lire cette liste d'url il faudra lancer ulr manuellement.

Si vous trouvez l'ajout de fichiers lents via ulr.py, rien ne vous empêche de créer un script bash qui fait un echo $1 >> /path/vers/le/fichier/urls