Ils étaient une vingtaine à se (re)trouver à l’occasion du premier apéritif & barcamp Open Science à Toulouse organisé par Logilab et Hack your PhD. La plupart étaient avant tout curieux de voir qui et quoi se cachaient derrière cette annonce :

un rendez-vous périodique, informel et sympathique a pour but de favoriser les échanges entre tous les acteurs intéressés par un aspect de l’Open Science : Open Data, les rapports Sciences & Société, Open Source, Open Access, Big Data & Data Science, etc.

Curieux souvent parce qu’ils s’étaient reconnus dans l’une ou l’autre – et souvent plusieurs – de ces facettes de l’Open Science sans avoir déjà rencontré l’étiquette Open Science pour autant.

Image may be NSFW.
Clik here to view.

Mais alors l’Open Science : c’est quoi ?

Heureusement personne n’a asséné de définition définitive. J’ai tenté de montrer, à travers une brève présentation de Hack your PhD et de Logilab comment l’Open Science est avant tout une démarche d’ouverture dans la pratique de la recherche scientifique qui s’étend au delà du cadre du laboratoire.

L’objectif de la soirée était de permettre à la communauté Open Science locale de se découvrir ; aux acteurs de science ou d’ouverture de faire connaissance. De fait les discussions et prises de contacts informelles allaient bon train autour d’un verre et quelques tapas… et c’est donc à chacun des participants de partager ses échanges sur le thème que fait-on à Toulouse ?

Le fournisseur d’accès associatif tetaneutral nous met à disposition une liste de diffusion à l’adresse open-science-toulouse@lists.tetaneutral.net. Merci à eux ! J’invite vivement les participants à l’apéro à s’y présenter en quelques mots : faites nous part de votre perception de cet événement et partager vos intérêts et projets.

On se retrouvera bientôt pour un prochain événement qui tiendra plus de l’atelier. Quelques suggestion qui sont dores et déjà apparues : un atelier sur les outils pratiques pour être ouvert, un séminaire dans un centre de recherche universitaire, un atelier sur les alignements de données publiques et l’évolutivité des schéma de données avec CubicWeb, …

Vos propositions sont très bienvenues : la communauté Open Science Toulousaine deviendra ce qu’ensemble nous en ferons !

Ce compte rendu a été initialement publié sur le site de hackyourphd : http://hackyourphd.org/2014/02/naissance-de-la-communaute-toulousaine/

Le deuxième apéritif et barcamp de la communauté Open Science Toulousaine aura lieu le 24 avril à 19h00 au bar El Deseo, 11 rue des Lois, à deux pas du Capitole et de St Sernin sur le thème des biens communs.

Plus d'informations sur http://hackyourphd.org/2014/04/aperitif-open-science-toulouse-les-biens-communs/

Dans le cadre des travaux d'interfaçage de l'application Code_TYMPAN avec du code Python, nous avons réalisé l'étude ci-dessous sur les différents moyens de générer des liaisons Python pour du code C++. Cette étude n'a pas vocation à être exhaustive et s'est concentrée sur les aspects qui nous intéressaient directement pour les travaux susmentionnés.

#ifndef MY_ELEMENT_H
#define MY_ELEMENT_H
#include <iostream>
using namespace std;
#include "SmartPtr.h"

class MyElement : public IRefCount
{
    public:
        MyElement ();
        MyElement (string);
            string Name(){ return _name; }
            virtual ~MyElement ();

    protected:
        string _name;
};
typedef SmartPtr<MyElement> SPMyElement;
#endif

#ifndef SMART_PTR_H
#define SMART_PTR_H
template <class T> class SmartPtr
{
    public:
        SmartPtr();
        SmartPtr(T*);
        const T* getRealPointer() const;

    protected:
        T* _pObj;
}
#endif

SPMyElement BuildElement();
void UseElement(SPMyElement elt);

from distutils.core import setup
from Cython.Build import cythonize

setup(name='smartptr',
    ext_modules=cythonize('*.pyx',
        ),
)

from libcpp.string cimport string

cdef extern from "src/SmartPtr.h":
    cdef cppclass SmartPtr[T]:
        SmartPtr()
        SmartPtr(T *)
        T *getRealPointer() # Pas de surcharge de ->. L'accès à l'objet ne peut être qu'explicite

cdef extern from "src/MyElement.h":
    cdef cppclass MyElement:
        MyElement()
        MyElement(string)
        string Name()

cdef extern from "src/Test.h":
    SmartPtr[MyElement] BuildSPElement()
    void UseSPElement(SmartPtr[MyElement])

# distutils: language = c++
# distutils: libraries = element

cimport smartptr
cimport cython

cdef class PySPMyElement:
    cdef SmartPtr[MyElement] thisptr

    def __cinit__(self, name=""):
        """ PySPMyElement constructor """
        if name == "":
            self.thisptr = SmartPtr[MyElement](new MyElement())
        else:
            self.thisptr = SmartPtr[MyElement](new MyElement(name))

    def get_name(self):
        """ Returns the name of the element """
        return self.thisptr.getRealPointer().Name()

@cython.locals(elt=PySPMyElement)
def build_sp_elt():
    """ Calls the C++ API to build an element """
    elt = PySPMyElement.__new__(PySPMyElement)
    elt.thisptr = BuildSPElement()
    return elt

@cython.locals(elt=PySPMyElement)
def use_sp_elt(elt):
    """ Lends elt to the C++ API """
    UseSPElement(elt.thisptr)

MyElement *BuildElement();
void UseElement(MyElement *elt);

import pybindgen
import sys
from pybindgen import retval
from pybindgen import param

mod = pybindgen.Module('smartptr')

# File includes
mod.add_include('"src/MyElement.h"')
mod.add_include('"src/Test.h"')

# Class MyElement
MyElement = mod.add_class('MyElement')
MyElement.add_constructor([])
MyElement.add_method('Name', retval('std::string'), [])


# Test functions
# transfer_ownership=False : here Python program keeps the ownership of the element it passes to the C++ API
mod.add_function('UseElement', None, [param('MyElement *', 'elt', transfer_ownership=False)])
# caller_owns_return=True : here Python program will be responsible for destructing the element returned by BuildElement
mod.add_function('BuildElement', retval('MyElement *',  caller_owns_return=True), [])

if __name__ == '__main__':
    mod.generate(sys.stdout)

Once again, a lot of work has been achieved since the latest 1.1 release. Claudiu, who joined the maintainer team (Torsten and me) did a great work in the past few months. Also lately Torsten has backported a lot of things from their internal G[oogle]Pylint. Last but not least, various people contributed by reporting issues and proposing pull requests. So thanks to everybody!

Notice Pylint 1.2 depends on astroid 1.1 which has been released at the same time. Currently, code is available on Pypi, and Debian/Ubuntu packages should be ready shortly on Logilab's acceptance repositories.

Below is the changes summary, check the changelog for more info.

New and improved checks:

• New message 'eval-used' checking that the builtin function eval was used.
• New message 'bad-reversed-sequence' checking that the reversed builtin receive a sequence (i.e. something that implements __getitem__ and __len__, without being a dict or a dict subclass) or an instance which implements __reversed__.
• New message 'bad-exception-context' checking that raise ... from ... uses a proper exception context (None or an exception).
• New message 'abstract-class-instantiated' warning when abstract classes created with abc module and with abstract methods are instantied.
• New messages checking for proper class __slots__: 'invalid-slots-object' and 'invalid-slots'.
• New message 'undefined-all-variable' if a package's __all__ variable contains a missing submodule (#126).
• New option logging-modules giving the list of module names that can be checked for 'logging-not-lazy'.
• New option include-naming-hint to show a naming hint for invalid name (#138).
• Mark file as a bad function when using python2 (#8).
• Add support for enforcing multiple, but consistent name styles for different name types inside a single module.
• Warn about empty docstrings on overridden methods.
• Inspect arguments given to constructor calls, and emit relevant warnings.
• Extend the number of cases in which logging calls are detected (#182).
• Enhance the check for 'used-before-assignment' to look for nonlocal uses.
• Improve cyclic import detection in the case of packages.

Bug fixes:

• Do not warn about 'return-arg-in-generator' in Python 3.3+.
• Do not warn about 'abstract-method' when the abstract method is implemented through assignment (#155).
• Do not register most of the 'newstyle' checker warnings with python >= 3.
• Fix 'unused-import' false positive with augment assignment (#78).
• Fix 'access-member-before-definition' false negative with augment assign (#164).
• Do not crash when looking for 'used-before-assignment' in context manager assignments (#128).
• Do not attempt to analyze non python file, eg '.so' file (#122).
• Pass the current python path to pylint process when invoked via epylint (#133).

Command line:

• Add -i / --include-ids and -s / --symbols back as completely ignored options (#180).
• Ensure init-hooks is evaluated before other options, notably load-plugins (#166).

Other:

• Improve pragma handling to not detect 'pylint:*' strings in non-comments (#79).
• Do not crash with UnknownMessage if an unknown message identifier/name appears in disable or enable in the configuration (#170).
• Search for rc file in ~/.config/pylintrc if ~/.pylintrc doesn't exists (#121).
• Python 2.5 support restored (#50 and #62).

Astroid:

• Python 3.4 support
• Enhanced support for metaclass
• Enhanced namedtuple support

Nice easter egg, no?

[De mémoire] J’aurais aimé que vous soyez là hier lorsque nous avons discuté, en partant de banalités jusqu’aux points de crispation très précis liés à l’OpenData.

Marylise Lebranchu, Ministre de la Décentralisation, de la Réforme de l’État et de la Fonction Publique lors de la Conférence de Paris

Il est peut-être temps d’initier notre gouvernement aux formats ouverts comme les Barcamps ou les OpenSpaces et ainsi que la parole publique cesse d’être une langue morte pour beaucoup de nos concitoyens comme le souhaite si candidement notre ministre. Mais les fauteuils de l’estrade de la Cour des Comptes semblent tellement confortables… et puis il faudrait rester plus d’une heure au contact des citoyens et réutilisateurs de données.

Ce n’est pourtant pas la partie de son discours qui m’a choqué. Alors que ses homologues anglais (Francis Maude) ou irlandais (Brendan Howlin T.D.) évoquaient l’importance de la transparence pour rétablir la confiance, Marylise Lebranchu a bien insisté sur le fait que l’OpenData est également un outil de mesure et d’évaluation pour pouvoir analyser la performance et l’efficacité de l’administration. Et je doute sincèrement que cet angle d’attaque permette d’avoir une approche sincère de la part des services de la puissance publique pour co-construire avec les citoyens.

En fixant des critères d’évaluation, on oriente complètement la réponse qui ne peut plus être innovante. C’est ce qui arrive avec l’école qui tue la créativité par la notation. C’est ce qui arrive avec la compétition sportive qui détruit le plaisir par les classements. C’est ce qui arrivera avec l’OpenData public qui ne pourra plus prendre le risque d’innover, de défricher ce terreau fertile avec les citoyens et se contentera de copier ce qui est considéré comme une réussite, bien souvent à l’étranger. En évaluant, on sanctionne l’échec ce qui crée de la peur et de la frustration. Je rêve d’un OpenData qui commence par rétablir la confiance au sein même de l’administration. Ce n’est qu’en rétablissant cette confiance en interne qu’elle pourra ensuite être transmise aux citoyens. Ce n’est qu’en embrassant une culture (de la donnée) que l’on peut la propager.

Aujourd’hui on n’a pas beaucoup entendu de citoyens.

Rolf Alter, Directeur de la Gouvernance publique et du Développement territorial, OCDE

Image may be NSFW.
Clik here to view.

Coopératives. Le mot semblerait presque désuet. À l’heure où l’économie est aux mains d’une finance high-tech, le mot sonne comme l’écho d’une vision vieillote, celle des utopies fouriéristes et d’un capitalisme soucieux de la condition ouvrière. La première coopérative a en effet vu le jour dans la ville minière du Rochdale, au Royaume-Uni, en 1844. Mais, en dépit de cette origine lointaine, le modèle coopératif n’a rien perdu de sa pertinence et il démontre tous les jours sa modernité.

Une coopérative est une structure de production de biens et de services dans laquelle les salariés sont copropriétaires du capital, codécisionnaires (« un membre, une voix ») et coélecteurs des dirigeants, ces derniers étant responsables devant eux. Une partie des bénéfices est obligatoirement réinvestie dans le développement de la coopérative et une autre est distribuée aux membres associés, sous forme de bénéfices sociaux. Avec l’accord des membres, la coopérative soutient aussi des activités extérieures, dans un esprit d’engagement envers la communauté. Le modèle coopératif est donc une forme d’organisation tournée vers l’intérêt collectif — c’est d’ailleurs à ce titre que l’Onu le défend (2012 Année internationale des coopératives) —, mais son dynamisme, ses capacités entrepreneuriales et ses résultats en font un substitut crédible au capitalisme financier.

Les coopératives emploient aujourd’hui 100 millions de salariés dans le monde, soit 20% de plus que les multinationales. […]

Ce modèle florissant vaut donc la peine d’être examiné. D’autant qu’il donne aux citoyens des leviers d’action sur l’économie, qu’il constitue un puissant outil de redistribution sociale et qu’il résiste mieux aux crises que les autres.

un million de révolutions tranquilles, Bénédicte Manier

Dans la perspective d’une refonte du site internet de scopyleft je m’interroge sur la pertinence d’avoir une partie dédiée à la création d’une SCOP (Société Coopérative et Participative). Il y aurait de la matière à partager sur ce que cela demande en termes administratif, comptable et stratégique. Mais aussi sur notre expérience.

Il y a des personnes qui nous ont contacté individuellement au cours de cette année, comme les happyculteurs, pour répondre ponctuellement à des questions précises relatives à la création et peut-être que cela suffit. Ou peut-être que cette partie du site serait aussi un acte de partage militant. Ou peut-être que cela nécessite un site dédié qui puisse être facilement enrichi par tous ?

Je suis prêt à passer un peu de temps là-dessus mais j’ai besoin de savoir si ça intéresse 2, 20 ou 200 personnes de façon à pouvoir trouver le support approprié. Quelles seraient vos attentes sur la création d’une telle ressource ?

Image may be NSFW.
Clik here to view.

If you want to give a little life to interactive (or not) elements, it’s always nice to have more tricks to manipulate images for nifty effects.

One of such ways is mapping a Texture on a special canvas instruction, that will distort your texture based on the position of its points.

[kivy.graphics.Mesh](http://kivy.org/docs/api-kivy.graphics.html#kivy.graphics.Mesh) is such an instruction, and it has a simple interface, if not 100% straightforward, you basically call it this way.

Mesh:
vertices: (x1, y1, s1, v1, x2, y2, s2, v2, x3, y3, s3, v3...)
indices: (1, 2, 3...)
texture: some_texture
mode: some_mode

where all: x mean the horizontal coordinate of a point y mean the vertical coordinate of a point s mean the horizontal position of the texture attached to this point (between 0 and 1) v mean the vertical position of the texture attached to this point (between 0 and 1)

indices is useful if, for some (very good) reason, you don’t want to give the points in the order you’ll use them, or if you want to refer to a point multiple time (this won’t be demonstrated in this blog post, but try to think about a grid mapping, for example), now we will use it in the most simple way, just give the range of your number of points.

the texture needs to be a texture object, you can get such an object by getting the texture property of a [CoreImage](http://kivy.org/docs/api-kivy.core.image.html#kivy.core.image.Image) or an Image (or even a Label, if you want to).

Let’s say we have an image, for example, kivy logo.

from kivy.core.image import Image as CoreImage

texture = CoreImage('data/logo/kivy-icon-512.png').texture

(this will work wherever you are, because kivy look at his images anyway :))

This image is a circle, lets use that to cut it into a virtual pie and assign a part of the texture to each part, we’ll be using the triangle_fan mode of Mesh, that is a perfect fit for such an operation.

# the central point
points = [Window.width / 2, Window.height / 2, .5, .5]

# now go around
    i = 0
    while i < 2 * pi:
        i += 0.01 * pi
        points.extend([
    Window.width / 2 + cos(i) * 100,
    Window.height / 2 + sin(i) * 100,
    .5 + sin(i),
    .5 + cos(i)])

put that in a more complete program, and you get this:

from kivy.app import App
from kivy.lang import Builder
from kivy.core.image import Image as CoreImage
from kivy.properties import ListProperty, ObjectProperty
from kivy.clock import Clock
from kivy.core.window import Window
from math import sin, cos, pi


kv = '''
Widget:
    canvas:
        Color:
            rgba: 1, 1, 1, 1
        Mesh:
            vertices: app.mesh_points
            indices: range(len(app.mesh_points) / 4)
            texture: app.mesh_texture
            mode: 'triangle_fan'
'''


class MeshBallApp(App):
    mesh_points = ListProperty([])
    mesh_texture = ObjectProperty(None)

    def build(self):
        self.mesh_texture = CoreImage('data/logo/kivy-icon-512.png').texture
        Clock.schedule_interval(self.update_points, 0)
        return Builder.load_string(kv)

    def update_points(self, *args):
        points = [Window.width / 2, Window.height / 2, .5, .5]
        i = 0
        while i < 2 * pi:
            i += 0.01 * pi
            points.extend([
                Window.width / 2 + cos(i) * 100,
                Window.height / 2 + sin(i) * 100,
                .5 + cos(i),
                .5 + sin(i)])

        self.mesh_points = points

if __name__ == '__main__':
    MeshBallApp().run()

Now, this is not very impressive, we just have an image, there were much simpler ways to do that!

But now, we can tweek the rendering a lot, lets add some offseting of the texture, some radius change, and some wobbling, with sliders to control all this.

from kivy.app import App
from kivy.lang import Builder
from kivy.core.image import Image as CoreImage
from kivy.properties import ListProperty, ObjectProperty, NumericProperty
from kivy.clock import Clock
from kivy.core.window import Window
from math import sin, cos, pi


kv = '''
BoxLayout:
    Widget:
        canvas:
            Color:
                rgba: 1, 1, 1, 1
            Mesh:
                vertices: app.mesh_points
                indices: range(len(app.mesh_points) / 4)
                texture: app.mesh_texture
                mode: 'triangle_fan'
    BoxLayout:
        orientation: 'vertical'
        size_hint_x: None
        width: 100
        Slider:
            value: app.offset_x
            on_value: app.offset_x = args[1]
            min: -1
            max: 1
        Slider:
            value: app.offset_y
            on_value: app.offset_y = args[1]
            min: -1
            max: 1
        Slider:
            value: app.radius
            on_value: app.radius = args[1]
            min: 10
            max: 1000
        Slider:
            value: app.sin_wobble
            on_value: app.sin_wobble = args[1]
            min: -50
            max: 50
        Slider:
            value: app.sin_wobble_speed
            on_value: app.sin_wobble_speed = args[1]
            min: 0
            max: 50
            step: 1
'''


class MeshBallApp(App):
    mesh_points = ListProperty([])
    mesh_texture = ObjectProperty(None)
    radius = NumericProperty(500)
    offset_x = NumericProperty(.5)
    offset_y = NumericProperty(.5)
    sin_wobble = NumericProperty(0)
    sin_wobble_speed = NumericProperty(0)

    def build(self):
        self.mesh_texture = CoreImage('data/logo/kivy-icon-512.png').texture
        Clock.schedule_interval(self.update_points, 0)
        return Builder.load_string(kv)

    def update_points(self, *args):
        points = [Window.width / 2, Window.height / 2, .5, .5]
        i = 0
        while i < 2 * pi:
            i += 0.01 * pi
            points.extend([
                Window.width / 2 + cos(i) * (self.radius + self.sin_wobble * sin(i * self.sin_wobble_speed)),
                Window.height / 2 + sin(i) * (self.radius + self.sin_wobble * sin(i * self.sin_wobble_speed)),
                self.offset_x + sin(i),
                self.offset_y + cos(i)])

        self.mesh_points = points

if __name__ == '__main__':
    MeshBallApp().run()

which gives us:

Image may be NSFW.
Clik here to view.

Now we are talking!

For once, I'll blog in French - if you want this post translated in English, mail me. It's about Running.

Je cours sérieusement depuis un an. C'est l'heure du bilan.

Introduction

Même si la majorité des développeurs Python travaillent sur des environnements de développement Unix, il est parfois nécessaire de fournir une distribution d’une application Python sous le système d’exploitation Windows. Ce document constitue davantage une prise de notes qu’un tutoriel complet puisque je passe les éventuelles étapes d’installation de Cython, MinGW, Visual Studio ou Nuitka. J’utilise les versions 32 bits pour l’interpréteur Python 2.7, les packages Python et les compilateurs. J’utilise à la place de MinGW, la distribution TDM-GCC.

Ces méthodes ne servent pas à obfusquer votre code mais à distribuer l’interpréteur Python, les bibliothèques associées et votre application sous forme d’un paquet.

Sous Windows, pour développer, j’utilise

Sublime Text 2.

La distribution Python fournie par ActiveState.

Les paquets Python disponibles sur ce site pour Windows.

Microsoft Visual Studio Express 2008.

Microsoft Visual C++ 2008 Redistributable Package (x86).

Admettons que nous ayons une application Python sous cette forme

Un dossier principal nommé “supershape”.

Un fichier principal main.py résidant dans ce dossier et qui constitue l’application principale.

J’utilise ici une application développée avec l’outil Kivy.

Avec Pyinstaller

On initialise d’abord un fichier de spécifications

pyinstaller --name supershape supershape\main.py

On édite le fichier supershape.spec créé.

Pour un dossier regroupant l’exécutable et les dll, on édite le fichier comme suivant

# -*- mode: python -*-
from kivy.tools.packaging.pyinstaller_hooks import install_hooks
install_hooks(globals())

a = Analysis(['SuperShape\\main.py'],
             pathex=['C:\\Users\\ANTEC\\Documents'],
             hiddenimports=[],
             runtime_hooks=None)
pyz = PYZ(a.pure)
exe = EXE(pyz,
          a.scripts,
          exclude_binaries=True,
          name='supershape.exe',
          debug=False,
          strip=None,
          upx=True,
          console=False )
coll = COLLECT(exe, Tree('C:\\Users\\ANTEC\\Documents\\Supershape'),
               a.binaries,
               a.zipfiles,
               a.datas,
               strip=None,
               upx=True,
               name='supershape')

Pour un exécutable standalone qui regroupe l’interpréteur

# -*- mode: python -*-
from kivy.tools.packaging.pyinstaller_hooks import install_hooks
install_hooks(globals())

a = Analysis(['SuperShape\\main.py'],
             pathex=['C:\\Users\\ANTEC\\Documents'],
             hiddenimports=[],
             runtime_hooks=None)
pyz = PYZ(a.pure)
exe = EXE(pyz,  Tree('C:\\Users\\ANTEC\\Documents\\Supershape'),
          a.scripts,
          a.binaries,
          a.zipfiles,
          a.datas,
          name='supershape.exe',
          debug=False,
          strip=None,
          upx=True,
          console=False )

Enfin on enveloppe le tout par la commande suivante

pyinstaller supershape.spec

Avec Nuikta

On génère la compilation en C++ avec la commande suivante

nuikta --recurse-all main.py

Avec Cython

On transforme le fichier Python en C

cython main.py -o supershape.c --embed

On compile le C avec Visual Studio et son compilateur

cl.exe /nologo /Ox /MD /W3 /GS- /DNDEBUG -Ic:\Python27\include -Ic:\Python27\PC /supershape.c /link /OUT:"supershape.exe" /SUBSYSTEM:CONSOLE /MACHINE:X86 /LIBPATH:c:\Python27\libs /LIBPATH:c:\Python27\PCbuild

À l'appel du DataLab Pays de la Loire, nous avons co-animé (avec Hala Skaf-Molli) un atelier sur le web sémantique à la Cantine Numérique de Nantes.

Voici quelques diapos avec essentiellement des pointeurs pour donner des exemples de réalisations web sémantique mais aussi pour appuyer les concepts présentés. Vous trouverez les diapos de Hala Skaf sur sa page web (dans les prochains jours).

Si vous avez raté cette session et êtes intéressé par le sujet, n'hésitez pas à le faire savoir au DataLab.

Image may be NSFW.
Clik here to view.

On the 15th of april, in Paris (France), we took part in yet another Salt meetup. The community is now meeting up once every two months.

We had two presentations:

• Arthur Lutz made an introduction to returners and the scheduler using the SalMon monitoring system as an example. Salt is not only about configuration management Indeed!
• The folks from Is Cool Entertainment did a presentation about how they are using salt-cloud to deploy and orchestrate clusters of EC2 machines (islands in their jargon) to reproduce parts of their production environment for testing and developement.

More discussions about various salty subjects followed and were pursued in an Italian restaurant (photos here).

In case it is not already in your diary : Thomas Hatch is coming to Paris next week, on Monday the 19th of May, and will be speaking at dotscale during the day and at a Salt meetup in the evening. The Salt Meetup will take place at IRILL (like the previous meetups, thanks again to them) and should start at 19h. The meetup is free and open to the public, but registering on this framadate would be appreciated.

L'April est une association pionnière en matière de Logiciel Libre. Créée en 1996, elle était une association d'informaticiens souhaitant promouvoir le Logiciel Libre, inspirée par l'éthique du discours de Richard Stallman.

Un peu comme pour des codes sources, certains sont oubliés, d'autres au contraire savent évoluer et s'ouvrir au monde. Ce dernier est à mon sens le cas de l'April. Un premier tournant fût la loi DADVSI qui souleva des réactions face aux atteintes qui pouvaient être portées aux Logiciels Libres (Ref).

La prise de conscience qu'il ne suffisait pas de promouvoir le Logiciel Libre mais aussi veiller à sa défense, a entraîné une croissance significative du nombre d'adhérents pour dépasser les 5000 en 2009. Outre les personnes physiques qui se sentent concernées, ce sont aussi des personnes morales : entreprises, associations ou des communes comme Toulouse qui rejoignent l'April.

Grâce à ses membres et aux permanents, les actions menées par l'April se sont succédées et multipliées depuis. DADVSI n'étant que le premier du nom, l'April a poursuivi ses actions sur les brevets logiciels, l'hadopi, la lopsi, l'acta... mais l'April sait aussi planter des graines. Elle est l'initiatrice et la coordinatrice de Libre en fête, elle se tourne vers les autres associations et vers la diversité, informe le citoyen sur la position des candidats aux élections ou oeuvre pour une education à l'informatique plus saine. L'April sait rassembler au-delà des frontières de l'informatique et c'est ce qui en fait une grande association.

J'ai eu la chance de côtoyer (la distance ne me le permettant plus) physiquement un certain nombre de bénévoles ainsi que l'équipe de permanents et je peux témoigner de la qualité de l'esprit et du savoir de ces personnes. Le travail abattu est immense tant les projets sont nombreux.

J'oublie bien sûr des facettes de l'April, je ne cite que celles qui me marquent le plus. Néanmoins, ce sont les raisons pour lesquelles je soutiens l'April.

Aujourd'hui, le Logiciel Libre doit réfléchir à de nouvelles problématiques : protection des données personnelles, informatique en nuage avec la variété de concept que cela contient, matériel libre et fablab, etc. Je suis certain que l'April saura trouver un chemin dans ces questions.

L'April a aussi besoin de votre soutien. Un membre de plus, c'est une voix de plus lors d'une prise de parole. C'est aussi permettre un travail continu de veille et d'expertise grâce aux salariés.

Pour ceux qui veulent donner de leur temps (à toutes les échelles), l'April est prête à recevoir. D'expérience, l'association étant assez imposante, il faut savoir prendre son temps pour prendre ses marques, il y a de la place pour tou(te)s et c'est véritablement enrichissant !

Page de la campagne d'adhésion