KrISS feed 8.7 - A simple and smart (or stupid) feed reader. By Tontof
  • Monday 10 September 2018 - 02:25

    Comme tous les mois (enfin, presque tous les mois puisque le dernier éditorial sur LinuxFr.org date de juin 2018… Bah oué, la période estivale tout ça… Si vous voulez consulter les éditoriaux de juillet et d’août 2018, des liens sont disponibles ci‐dessous), LinuxMAO vous apporte ici son lot de nouveautés et vous permet de vous tenir au courant de l’actualité musicale. Nouveaux projets, nouvelles publications, nouvelles réalisations, dernières mises à jour de logiciels… Allez vite lire la deuxième partie de la dépêche.

    Logo de LinuxMAO.org

    Article sous licence CC By-SA 2.5 (comme l’originel sur LinuxMAO.org).

    Sommaire

    Le petit Roger prépare sa rentrée des classes.
    Tout est nouveau pour lui car, après des études primaires maussades, il a choisi de s’orienter vers un cursus secondaire inédit : « MAO sous GNU/Linux, option synthèse sonore ». Il sera pensionnaire. Le seul collège proposant cette section se trouve dans une lointaine contrée imaginaire.
    Il a fébrilement préparé cartable, trousse, banques de sons, clavier maître et affûté ses oreilles tout l’été aux sons de l’IRCAM, de Kraftwerk, d’un large éventail de techno et de drum & bass.
    Là où il bloque encore, c’est sur le choix de la carte son par laquelle transiteront ses créations audio et MIDI. Un camarade de camping, cet été, lui a fait connaître LinuxMAO.org et l’a assuré qu’il trouverait aide et conseils de la part de cette communauté libre et désintéressée. Début septembre, il s’inscrit sur le site et, dès le lendemain, après de méthodiques lectures, publie sur le forum, section « le home‐studio, les instruments et le DIY », sa liste de questions studieusement préparée.
    La solution fut trouvée après deux jours d’échanges amicaux avec trois des membres du site.
    Roger, ravi, ne manque pas de remercier les trois intervenants, tout fier d’avoir pu ajouter le traditionnel « [résolu] » dans le titre de son fil.
    Dès réception du matériel tant convoité, il n’a pas manqué de relater en détails son retour d’expérience, dans un article qu’il a pris l’initiative d’écrire seul, copiant‐collant un sujet similaire portant sur un autre matériel, juste en en modifiant le contenu.
    Roger a tout pigé. Il sait que la richesse du site est faite de plusieurs milliers de contributions telles que la sienne, telles que les vôtres, et que le plaisir d’y circuler tient parfois juste à un « merci ! » enthousiaste…
    Vous tous, nouveaux inscrits tant et tant bienvenus, prenez quelques minutes de votre temps musical pour lire le court manuel du site LinuxMAO.org.

    Bonne rentrée, bien souriante, à vous tous !

    Quoi de neuf ?

    Depuis la parution du dernier éditorial, nous ont rejoint : EmmanuelDumas, BARBARAEYDELY, Epiqure, amphyper, lightpow, sikinosiki, ScoreItOnLinux, sickboy, hapkin, maaou68, HoneyBearBassPlayer, dadoudidon, graphicspad, neoshell, lalilala, georges74, maharo, Nydoxic, GhostOfBushes, TotoLeTroll, eleatus et crazyman.
    Bienvenue à vous toutes et tous !

    Musique sur LinuxMAO.org

    Musique libre en dehors de LinuxMAO.org

    Liste de lecture des nouveautés pour le mois d’août 2018 chez les copains de Dogmazic.

    À noter qu’un concours ayant pour principes/contraintes d’utiliser certains synthétiseurs à modulation de fréquence (FM) libres pour produire de la musique libre devrait démarrer probablement bientôt : https://fmchallenge.osamc.de/. Nous pouvons constater que le logiciel 6PM de m2v2 figure parmi les sept synthétiseurs FM sélectionnés ! Les autres étant : Dexed, le MDA DX10, Hexter, JuceOPLVSTi, OpulenZ (un des synthés embarqués de LMMS et Oxe FM Synth.

    Nouvelles du monde

    Annoncé sur la liste de diffusion/discussion de développement d’ALSA : ALSA-dev, la mini‐conférence audio annuelle aura lieu le 21 octobre 2018 à Édimbourg. Ci‐dessous, une traduction rapide du message d’annonce :

    « Comme les années précédentes, nous essayons d’organiser une mini‐conférence audio pour que nous puissions nous réunir et discuter des problèmes, en particulier des décisions de conception, en face‐à‐face. L’événement de cette année aura lieu le dimanche 21 octobre à Édimbourg, la veille de l’ouverture de l’ELC Europe. Nous sommes encore en train de finaliser le site (nous espérons pouvoir confirmer la semaine prochaine), mais il sera à l’extérieur du site de l’ELC, de sorte qu’il ne sera pas nécessaire d’acheter un billet de l’ELC pour y assister.

    Comme pour les années précédentes, nous établissons un ordre du jour par le biais d’une discussion sur une liste de diffusion — si vous le pouvez, répondez à ce courriel avec des sujets que vous aimeriez voir discutés et dont vous apprécieriez que l’on s’occupe. Bien sûr, si nous pouvons régler les choses plus rapidement via la liste de diffusion, c’est encore mieux !

    Si vous avez l’intention d’y assister, veuillez remplir le formulaire. »

    À noter que l’utilisateur fulup-bzh semble vouloir y envoyer deux de ses collaborateurs dans le cadre de son travail (audio embarqué en automobile). Fulup a contribué au site LinuxMAO.org et a également un projet de mixeur audio avec le couple AJG/AJM (AlsaJsonGateway et AlsaJsonMixer). Espérons ici qu’il ait envie de nous faire un petit débriefing !

    Annoncé sur la liste linux-audio-dev, la première conférence internationale à propos de Faust (IFC 2018, IFC pour International Faust Conference) a eu lieu à l’Université Johannes Gutenberg à Mainz, en Allemagne, courant juillet. Si le sujet vous intéresse et que vous n’avez pas pu vous y rendre, vous pouvez trouver les vidéos de toutes les présentations et la cérémonie du prix Faust sur le chaîne YouTube. Toutes les vidéos sont présentes dans une liste de lecture unique qui reflète (presque entièrement) le programme.

    Tant que nous sommes dans les vidéos de conférence, les vidéos de la LAC (Conférence Audio Linux) 2018 sont disponibles sur le site de l’accueillant, ainsi que sur les pages dédiées aux événements liés sur le programme. Vous pouvez donc voir ou revoir ce qu’il s’est passé cette année à la LAC de Berlin.

    Nouveautés sur LinuxMAO.org

    Les chiffres

    Le nombre de visiteurs uniques du mois d’août 2018 est de 32 822. LinuxMAO.org, c’est à ce jour, 6 037 utilisateurs inscrits, 2 338 « pages de documentation », les plus de 88 000 messages dans les « forums » et d’autres fioritures.

    D’autre part, nous avons eu 22 nouvelles inscriptions depuis la rédaction du dernier éditorial du site, c’est‐à‐dire en 32 jours.

    Nouvelles pages

    Côté administration

    • la page jackdbus passe du portail logiciel aux archives ;
    • réattribution des messages à leurs auteurs originels dans ce fil de discussion ;
    • modification de la « balisecode » pour y ajouter un lien vers le manuel du site, section « forum » ;
    • maintenance générale du site.

    Côté logiciel sur LinuxMAO.org

    Côté logiciel en dehors de LinuxMAO.org

    Depuis la publication du dernier éditorial, olinuxx, sub26nico, syberia303 et Sylv_01 ont relevé les mises à jour suivantes.

    Pour ce mois‐ci :

    Pour les mois précédents (mais que nous n’avions pas vu jusque‐là) :

    • Calf Studio Gear est passé en version 0.90.1, le 8 juillet ;
    • Vee One Suite est passé en version 0.9.2 le 24 juillet ;
    • QjackCtl est passé en version 0.5.3 le 22 juillet ;
    • Qsynth est passé en version 0.5.2 le 22 juillet ;
    • Qsampler est passé en version 0.5.2 le 22 juillet ;
    • QXGedit est passé en version 0.5.2 le 22 juillet ;
    • Qmidinet est passé en version 0.5.2 le 22 juillet ;
    • Jack Keyboard est passé en version 2.7.2 le 21 juin ;
    • sonic-pi est passé en version 3.1.0 le 23 janvier.

    Post‐scriptum

    Merci à allany, olinuxx, r1 et sub26nico pour l’écriture de cet édito. Et l’on se retrouve le mois prochain pour une revue de l’actualité du mois écoulé !

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Monday 10 September 2018 - 17:02

    Python 3.7 a été publié le 27 juin 2018, soit un an et demi après la précédente version. Celle‐ci vient avec son lot de nouveaux modules et fonctionnalités que nous détaillons dans la suite de la dépêche.

    Logo de Python

    Sommaire

    Python 3.7 en résumé

    La fonctionnalité la plus « marquante » est sans doute l'introduction du module dataclasses qui permettra aux développeurs d'écrire des classes avec une syntaxe bien plus concise qu'à l'accoutumée. Une nouvelle fonction native a été introduite à savoir breakpoint() facilitant l'utilisation du débogueur et offrant la possibilité, pour des usages plus avancés, de le personnaliser. Le module asyncio a été fortement amélioré, notamment en simplifiant l'API, en plus de cela, async et await deviennent désormais des mots clefs. Ajoutons à cela, le fait que la conservation de l'ordre d'insertion des dict est désormais officielle d'après les spécifications, et vous aurez une bonne vision des modifications liées à la syntaxe du langage.

    Python 3.7 apporte aussi des améliorations sur des fonctionnalités plus avancées, comme la possibilité de personnaliser l'accès aux attributs de module, mais aussi l'introduction du module typing dans le cœur de Python, ainsi que la possibilité d'effectuer une évaluation différée des annotations, ce qui amène à Python des évolutions intéressantes concernant son système de typage.

    Enfin, cette version vient avec la possibilité de faire des builds reproductibles, et de très nombreuses améliorations de performance faisant de Python 3.7 la version la plus rapide de Python.

    Nouveaux modules

    PEP 557 : Dataclasses

    La PEP 557 introduit le nouveau module dataclasses qui fournit le décorateur @dataclass permettant d'écrire une « classe de données » de façon plus concise. Les dataclasses peuvent être vues comme un namedtuple mutable avec des valeurs par défaut. Le décorateur de classe repose sur la PEP 526 qui a introduit les annotations de variables. On peut donc désormais écrire ceci en Python 3.7 :

    from dataclasses import dataclass
    
    @dataclass
    class BankAccount:
        """class that corresponds to a bank account."""
        bank_name: str  # no default value
        owner_name: str
        currency: str = "dollar"  # assign a default value for 'currency'
        value: int = 0
    
        def tax(self, val) -> int:
            self.value -= val

    Cela donne ensuite :

    >>> print(BankAccount('BNP', 'toto'))
    BankAccount(bank_name='BNP', owner_name='toto', currency='dollar', value=0)
    >>> account = BankAccount('LCL', 'tata', 'euros', 1000)
    >>> account.tax(5)
    >>> print(account.value)
    995

    L'intérêt d'utiliser une dataclass et non pas un namedtuple, c'est qu'il s'agit ni plus ni moins d'une classe normale en Python. On peut donc utiliser tous les concepts de la programmation objet associés aux classes (héritage, métaclasse, docstrings). On voit dans l'exemple ci-dessus que le décorateur va générer une classe, et va fournir automatiquement le __init__, __repr__, ainsi que la fonction d'égalité __eq__.

    >>> print(account)
    <class '__main__.BankAccount'>
    >>> dir(account1)
    ['__annotations__', '__class__', '__dataclass_fields__', '__dataclass_params__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bank_name', 'currency', 'owner_name', 'tax', 'value']

    Il est possible de passer des paramètres au décorateur pour générer, par exemple, des fonctions de comparaisons avec le paramètre order. Par exemple, la classe suivante permettra de faire des comparaisons.

    @dataclass(order=True)
    class Item:
        price: float
        product_name: str 
    
    >>> pomme = Item(1.5, 'pomme')
    >>> ordinateur = Item(500, 'ordinateur')
    >>> pomme < ordinateur
    True

    Python va comparer les éléments en considérant que les éléments sont des tuples, il va donc comparer les champs un par un.

    Il est possible de convertir une instance dataclass en tuple ou dict via les fonctions astuple() ou asdict() disponibles dans le module. Dans l'exemple ci-dessus, cela donne :

    from dataclasses import astuple, asdict
    >>> print(astuple(pomme))
    (1.5, 'pomme')
    >>> print(asdict(pomme))
    {'price': 1.5, 'product_name': 'pomme'}

    Les dataclasses peuvent faire penser à l'utilisation que l'on peut faire des namedtuples, mais ces derniers ont certaines restrictions. De par leur nature, ce sont des objets immuables. Ainsi, si l'on écrit :

    from collections import namedtuple
    Item = namedtuple('Item', ['price', 'product_name'])
    apple = Item(2, 'apple')

    Modifier le champ price va provoquer une erreur :

    >>> apple.price = 3
    AttributeError: can't set attribute

    De même, on peut accidentellement comparer deux namedtuples qui ont les mêmes valeurs, mais qui ne représentent pas les mêmes objets.

    Stock = namedtuple('Stock', ['quantity', 'name'])
    apple_stock = Stock(2, 'apple')
    >>> apple_stock == apple
    True

    L'utilisation de dataclass empêche cela car la comparaison de deux objets de classes différentes renverra toujours False.

    PEP 567 : Variables contextualisées

    Cette nouvelle fonctionnalité demande une petite introduction.

    Si on prend un programme « classique » mono-thread avec une exécution linéaire, toutes les variables sont accessibles simplement en lecture ou écriture et ne sont pas susceptibles de changer. Jusque-là, rien de compliqué.

    Maintenant, prenons le cas d'un programme multi-thread. Le contexte d'exécution — et en particulier toutes les variables — est partagé entre toutes les threads. Il est donc difficile pour une thread de manipuler des données privées, réservées à la thread. Python propose une solution pour ce problème avec l'API threading.local qui fournit un objet où la modification et la récupération d'une variable donnée pourra être différente suivant la thread qui l'appelle.

    Avec l'arrivée de l'asynchronicité dans l'exécution du code, de nouveaux problèmes se présentent : on peut avoir à l'intérieur de la même thread d'exécution plusieurs fonctions qui s'exécutent de façon asynchrone et qui auraient besoin d'un contexte différent par fonction plutôt que par thread.

    C'est ce problème que résout le nouveau module contextvars. Son introduction a été discutée et approuvée via la PEP 567 - Variables contextualisées. Cette PEP est elle-même un sous-ensemble d'une PEP plus ambitieuse, la PEP 550 - Contexte d'exécution. Cette dernière apportait la notion de contexte à un ensemble plus large de construction Python (en particulier les générateurs) mais n'a pas fait l'unanimité parmi les core-développeurs. L'auteur de la PEP, Yury Selivanov, a repris les parties qui faisaient consensus dans la PEP 567 qui a été intégrée dans Python 3.7.

    L'exemple suivant utilise asyncio et une liste pour créer trois contextes différents dans init_var(), puis le programme l'appel de la fonction hello() à chaque fois avec une valeur différente de name programmée dans le contexte.

    import contextvars
    import asyncio
    import datetime
    
    all_names = ['Donald', 'Mickey', 'Dominique']
    
    # La variable contextuelle
    name = contextvars.ContextVar('name')
    
    def hello():
        date = datetime.datetime.now().strftime('%H:%M:%S')
        print('Bonjour {}, il est {}'.format(name.get(), date))
    
    def init_var(event_loop):
        name.set(all_names.pop())
        event_loop.call_later(1, hello)
    
    # on récupère une boucle d'évènements
    event_loop = asyncio.get_event_loop()
    
    # on planifie des appels toutes les secondes
    event_loop.call_later(0, init_var, event_loop)
    event_loop.call_later(1, init_var, event_loop)
    event_loop.call_later(2, init_var, event_loop)
    
    # on prévoit de s'arrêter tout de même
    event_loop.call_later(5, event_loop.stop)
    
    # on met tout en route et on attend
    event_loop.run_forever()

    Le résultat :

    >py -3.7 asyncio_example2.py
    Bonjour Dominique, il est 13:10:03
    Bonjour Mickey, il est 13:10:04
    Bonjour Donald, il est 13:10:05
    

    Ajout de l'API importlib.resources pour lire des ressources embarquées

    Le terme ressource désigne ici un fichier de données. Avec cette nouvelle API, il est possible d'accéder en lecture à un fichier qui serait embarqué dans un package Python, et donc installé en même temps que le package. Ou bien de donner un accès en lecture à une donnée qui fait partie de l'application distribuée mais n'est pas représentée strictement comme un fichier.

    Accéder à des ressources de données est un besoin courant pour certains types d'applications. Par exemple, les applications graphiques peuvent ainsi distribuer aisément leurs icônes et images.

    Avant la disponibilité de cette API, embarquer un fichier de données au packaging et y accéder à l'exécution se faisait soit à coups de bidouilles sur la variable __file__ pour localiser le module en cours et en déduire l'emplacement du fichier (la méthode old-school, qui marchait pas toujours dans des environnements complexes), soit en utilisant l'API Basic Resource Access de setuptools, l'outil de packaging de Python.

    C'est surtout ce dernier qui est remplacé par la nouvelle API, plus robuste et plus simple à utiliser. Une documentation spécifique est disponible pour migrer de pkg_resources à importlib.resources, en plus de la documentation standard.

    À noter la disponibilité d'un portage vers les précédentes versions de Python (2.7, 3.4, 3.5 et 3.6) via le package importlib_resources sur PyPi. C'est d'ailleurs dans ce package que l'API a maturé dans les six derniers mois avant de rejoindre Python 3.7.

    Syntaxe et caractéristiques des dictionnaires

    async et await deviennent des mots clefs réservés

    Pour éviter les problèmes de rétro-compatibilité, async et await n'ont pas été ajoutés à la liste des mots clés réservés lorsqu'ils ont été inclus dans Python 3.5.

    Il était donc possible de nommer des variables et des fonctions async ou await.

    Dorénavant, ce n'est plus possible en Python 3.7 :

    >>> async = 42
      File "<stdin>", line 1
        async = 42
              ^
    SyntaxError: invalid syntax
    >>> def await():
      File "<stdin>", line 1
        def await():
                ^
    SyntaxError: invalid syntax

    Ordre d'insertion dans les dictionnaires

    La conservation de l'ordre d'insertion dans les dict est désormais officielle. Ce comportement provient au départ d'un effet de bord de l'amélioration de l'implémentation des dictionnaires (consommation mémoire réduite de 20 à 25 %) réalisée pour la version 3.6. Cette propriété a été dans un premier temps définie en tant que détail d'implémentation de CPython 3.6 afin de ne pas trop perturber la compatibilité arrière et les autres implémentations de Python.

    Concrètement, en Python 3.5 :

    >>> d = {}
    >>> d['a'] = 1
    >>> d['z'] = 2
    >>> for k in d: print(k)  # affiche toutes les cles du dictionnaire
    z
    a

    L'ordre de parcours des clés du dictionnaire est non-défini à l'avance, et peut bouger au fur à mesure que le dictionnaire évolue :

    >>> d['j'] = 3
    >>> for k in d: print(k)  # affiche toutes les cles du dictionnaire
    z
    j
    a

    Le nouvel élément ajouté a changé l'ordre de parcours.

    Maintenant, en Python 3.6 et 3.7 :

    >>> d={}
    >>> d['a'] = 1
    >>> d['z'] = 2
    >>> for k in d: print(k)
    a
    z
    >>> d['j'] = 3
    >>> for k in d: print(k)
    a
    z
    j

    Les clés sont maintenant affichées dans l'ordre où elles ont été ajoutées au dictionnaire. Un effet de bord sympa est que pour les fonctions à arguments par mot-clés, l'ordre est préservé aussi :

    L'ancien comportement en Python 3.5 :

    >>> def f(**kw):
    ...   for k in kw: print(k)
    >>> f(a=1, j=2, z=3)
    z
    j
    a
    >>> f(z=3, a=2, j=1)
    z
    j
    a

    On constate que l'ordre d'affichage des clés est celui du dictionnaire utilisé, et va donc varier en fonction des clés du dictionnaire.

    Maintenant, en Python 3.6 et 3.7 :

    >>> f(a=1, j=2, z=3)
    a
    j
    z
    >>> f(z=3, j=2, a=1)
    z
    j
    a

    L'ordre d'affichage dépend désormais de l'ordre de création des clés.

    C'est pas une killer-feature de Python, mais c'est plutôt confortable.

    Note personnelle de l'un des auteurs : ça m'est arrivé plusieurs fois lors de phases de debug d'être perturbé parce que les nouvelles entrées dans un dictionnaire étaient affichées au milieu plutôt qu'à la fin. Ce ne sera plus le cas.

    À noter que la classe OrderedDict du module collections devient beaucoup moins utile, mais pas nécessairement obsolète : son auteur Raymond Hettinger explique dans un mail que l'implémentation de OrderedDict est optimisée afin de permettre des ré-ordonnancements rapides et fréquents lors de l'évolution du dictionnaire. Ce n'est pas le cas des dict normaux qui eux sont optimisés pour être compacts en mémoire et rapides lors des accès. Une autre différence est que pour être égaux, deux dict normaux ont besoin d'avoir les mêmes clés et valeurs, alors que deux OrderedDict ajoutent la contrainte que les clés ont été insérées dans le même ordre.

    Améliorations

    PEP 553 : Introduction de la fonction breakpoint()

    La PEP 553 introduit la nouvelle fonction native breakpoint() pour faciliter et uniformiser l'accès au débogueur Python.

    Auparavant, pour faire appel à pdb, le débogueur standard de Python, vous deviez écrire import pdb; pdb.set_trace(). Désormais, vous pourrez faire breakpoint() uniquement.

    Cela a pour premier avantage de réduire le nombre de caractères à taper, et que ce soit plus facile à retenir, mais le véritable avantage est la possibilité de personnaliser le comportement du débuggeur.

    En effet, cette nouvelle fonction native fait appel à la fonction sys.breakpointhook() qui elle-même interroge une nouvelle variable d'environnement nommée PYTHONBREAKPOINT. Selon la valeur choisie, on peut désactiver le débogage (pour le désactiver dans un environnement de prod), utiliser le comportement par défaut avec l'appel à pdb, ou appeler un autre débogueur (celui intégré dans l'IDE utilisé, par exemple).

    PEP 560 et PEP 563 : Améliorations autour des annotations

    Les annotations des paramètres et valeur de retour de fonctions ont été introduites en même temps que le passage à Python 3.0, par la PEP 3107 en 2006. À l'époque, la syntaxe a été choisie de façon « neutre » afin de ne pas forcer un fonctionnement spécifique alors que l'annotation de type était encore quelque chose de très expérimental (voire inexistant) et novateur. Guido avait bien en tête que cela évoluerait vers de l'annotation de type poussée (cf. son blog) mais il était trop tôt pour figer cela dans le marbre et surtout le passage à Python 3 occupait déjà beaucoup de monde.

    Par neutre, on entend qu'on pouvait rajouter des trucs (techniquement des expressions) après les arguments et les valeurs de retour des fonctions mais que ces trucs étaient totalement ignorés par l'implémentation, en dehors du fait qu'ils soient accessibles.

    Les annotations étaient décrites dans la grammaire en tant que :

        def foo(a: expression, b: expression = 5, *args: expression, **args: expression) -> expression:
            ...

    Les deux exemples d'utilisation potentielle donnés dans la PEP étaient :

        def compile(source: "something compilable",
                    filename: "where the compilable thing comes from",
                    mode: "is this a single statement or a suite?"):
            ...
    
        def haul(item: Haulable, *vargs: PackAnimal) -> Distance:
            ...

    Évidemment, c'était surtout le cas haul() qui motivait l'évolution.

    L'aspect « neutre » signifiait qu'en dehors de la syntaxe du langage et d'une fonction pour rapatrier la chaîne de l'annotation, on ne touche pas au fonctionnement interne du langage.

    Avançons de huit années, jusqu'en 2014. Durant ces huit ans, des outils se sont emparés des possibilités ouvertes par l'annotation de type et permettent ainsi de vérifier statiquement la cohérence des types d'un ensemble de module Python. Le plus connu alors est mypy développé par l'équipe de Dropbox dans laquelle travaille Guido. Lorsqu'on l'exécute sur un ensemble de code Python, il fournit un rapport sur la cohérence globale des types déclarés dans les fonctions et leur utilisation (de la même façon que les compilateurs C++/Java/…).

    En 2014, Guido propose une nouvelle PEP, la PEP 484 - Indication de types, pour standardiser la façon dont on décrit le type d'un paramètre dans les annotations. Le but est de permettre aux différents outils travaillant avec les annotations de type d'utiliser un vocabulaire commun.

    Cette PEP ajoute un module typing à Python 3.5, qui permet de définir des types complexes à utiliser lors de l'annotation de type. Le module est provisionnel, ce qui veut dire qu'il est proposé en l'état mais qu'il pourrait encore évoluer.

    Concrètement, on peut maintenant écrire :

        def adder(val: int, l: Sequence[int]) -> List[int]:
            ret = []
            for v in l:
                ret.append( v+val )
            return ret

    L'annotation val: int était déjà possible avant. La nouveauté de la PEP 484 concerne tous les types élaborés comme Sequence, List, Dict, Any ainsi que toutes les constructions pour fabriquer des types plus spécifiques ou plus génériques.

    Le code ci-dessus nécessite d'être préfixé par la ligne suivante :

        from typing import Sequence, List

    En effet, les annotations sont des expressions ordinaires qui respectent la syntaxe Python.

    On note aussi la syntaxe inhabituelle, <container class> [ <type> ]. Il fallait une syntaxe lisible (pour rester dans l'esprit du langage) mais distincte de ce qui existe déjà, et qui ne crée pas de confusion pour le parser Python. Il y a eu pas mal de débat pour arriver à ce choix.

    Cette syntaxe est possible grâce à l'utilisation d'une méthode __getitem__() dans la méta-classe . Si vous ne savez pas ce qu'est une méta-classe, ne vous en faite pas, c'est très très spécifique. En gros, une méta-classe fonctionne pour une classe de la même façon qu'une classe pour une instance : elle permet de contrôler la création de la classe et de lui adjoindre des méthodes génériques disponibles pour toutes les classes qui y réfèrent. Ça permet notamment d'adjoindre et de partager des comportements génériques par des classes sans passer par le système classique d'héritage. On pourrait écrire trois pages sur le sujet sans le couvrir réellement.

    Toujours est-il qu'on reste dans l'esprit d'une modification « neutre » du langage au sens où on utilise deux fonctionnalités déjà présentes, un module et des méta-classes pour proposer l'annotation de type.

    La prise en charge des annotations a continuée d'évoluer, avec dans Python 3.6 la PEP 526 - Une syntaxe pour les annotations de variables, qui permet désormais d'annoter le type d'une variable en plus des arguments d'une fonction.

    Concrètement, cela prend la forme de :

        primes: List[int] = []
    
        captain: str  # Note: no initial value!
    
        class Starship:
            stats: ClassVar[Dict[str, int]] = {}

    C'est particulièrement utile lors de l’initialisation de conteneurs vides, pour lesquels l'analyseur de type ne peut savoir qu’elle sera les types stockés.

    C'est une standardisation dans le langage d'une fonctionnalité déjà présente dans mypy qui permettait la même chose mais en s'appuyant sur des commentaires :

        primes = []  # type: List[int]
    
        class Starship:
            stats = {}  # type: ClassVar[Dict[str, int]]

    Pour en revenir aux annotations, la neutralité et la généricité ont commencé à montrer leur limites lorsqu'on en fait un usage intensif. C'est ce qui est arrivé ces dernières années, et qui ont motivé deux PEP implémentées dans Python 3.7 .

    L'utilisation poussée du module typing a montré qu'il était plutôt lent, du fait de l'utilisation intensive des méta-classes et notamment de l'héritage multiple de méta-classes. C'est pourquoi Python 3.7 introduit la PEP 560 - Gestion dans le cœur de Python du module typing et des types génériques. Comme le dit son nom, cette PEP intervient dans le cœur de l'interpréteur CPython, sur des aspects techniques et hard-core pour accélérer et simplifier le module typing .

    De son côté, la PEP 563 - Évaluation différée des annotations, vise à corriger une erreur de jeunesse sur les annotations : celles-ci sont évaluées lors du chargement des modules Python. Pour un programme qui contient beaucoup d'annotations, il y a donc un coût en temps, au démarrage du programme, alors même que les annotations ne sont pas utilisées. L'autre inconvénient est que l'évaluation directe ne permettait pas les références par avance (forward references), où on définit plus bas dans le code un type qu'on souhaite utiliser dès maintenant pour l'annotation.

    La proposition de la PEP est de stocker la chaîne de caractère de l'expression dans le champ __annotation__, plutôt que directement le résultat de l'expression évaluée. Pour les outils de vérification de type, ça ne change rien car il était déjà possible de stocker une chaîne de caractère, pour résoudre justement le problème des références par avance.

    Pour d'autres usages des annotations, il faudra forcer un appel eval(ann, globals, locals) pour obtenir l'expression de l'annotation. À noter que l'expression n'est plus évaluée dans son périmètre d'origine (à l'analyse du module) mais dans le périmètre qui appelle eval, ce qui peut avoir des conséquences si l'expression utilisait des variables du périmètre local. Pour cette raison, c'est un changement incompatible avec le passé.

    Du fait de cette incompatibilité, beaucoup de précautions sont prises pour l'activation de cette fonctionnalité :

    • pour Python 3.7, ce n'est pas actif par défaut et il faudra un import explicite pour en bénéficier :
        from __future__ import annotations
    • pour Python 3.8, l'utilisation d'annotations incompatibles avec la PEP 563 déclenchera un PendingDeprecationWarning, signifiant en gros « attention, bientôt, l'usage sera obsolète ». On parle ici juste de l'usage d'expression dans les annotations qui dépendent du périmètre local, le reste fonctionne très bien en l'état ;
    • pour Python 3.9, on passera à un DeprecationWarning, signifiant cette fois, « maintenant, cet usage est obsolète » ;
    • et pour Python 4.0, une erreur sera levée à la compilation.

    À noter qu'avec ces deux PEP, les annotations de type rentrent dans le cœur du langage Python, même si elles restent totalement optionnelles.

    Amélioration du module asyncio

    Le module asyncio a été introduit dans Python 3.4 pour gérer les entrées/sorties asynchrones, les boucle d’évènements, les co-routines et les tâches. Dans Python 3.7, asyncio a reçu plusieurs nouvelles fonctionnalités ainsi que des améliorations d'utilisabilité et de performance.

    Parmi les nouveautés, on peut citer la nouvelle fonction asyncio.run() qui simplifie l'appel de co-routine depuis un code synchrone :

    import asyncio
    
    async def bonjour():
        print('Bonjour les Moules< !')
    
    asyncio.run(bonjour())

    Autre nouveauté, asyncio accepte maintenant les variables de contexte. Voir la PEP 567 pour plus de détails.

    La nouvelle fonction asyncio.create_task() a été ajoutée comme raccourci de asyncio.get_event_loop().create_task().

    La nouvelle fonction asyncio.current_task() retourne la tâche courante et la nouvelle fonction asyncio.all_tasks() retourne l'ensemble des tâches existantes dans une boucle donnée. Les méthodes Task.current_task() et Task.all_tasks() sont devenues obsolètes.

    La nouvelle fonction asyncio.get_running_loop() retourne la boucle courante et lance une RuntimeError si il n'y a pas de boucle s'exécutant actuellement. À la différence de asyncio.get_event_loop() qui va créer une nouvelle boucle plutôt que de lancer une exception.

    La nouvelle méthode StreamWriter.wait_closed() permet d'attendre jusqu'à la fermeture d'un flux. StreamWriter.is_closing() peut être utilisé pour savoir si le flux est en cours de fermeture.

    La nouvelle méthode loop.sock_sendfile() permet l'envoi de fichier en utilisant os.sendfile quand c'est possible.

    Les nouvelles méthodes Task.get_loop() et Future.get_loop() retournent leur boucle d'origine. Server.get_loop() permet de faire la même chose pour les objets asyncio.Server.

    Il est maintenant possible de contrôler le lancement des instances asyncio.Server. Avant, le serveur se lançait immédiatement après sa création. Le nouvel argument start_serving de loop.create_server() et loop.create_unix_server(), ainsi que Server.start_serving(), et Server.serve_forever() peut être utilisé pour découpler l'instanciation du serveur et le lancement du serveur. La nouvelle méthode Server.is_serving() retourne True si le serveur est lancé.

    Les objets retournés par loop.call_later() ont maintenant une méthode when() qui retourne leur heure d'exécution estimée.

    Les exceptions lancées lorsqu'une tâche est annulée ne sont plus journalisées.

    Plusieurs APIs asyncio sont devenues obsolètes.

    PEP 564 : Gestion des nanosecondes pour le module time

    Après avoir permis à Python 3.3 d'avoir une horloge monotone, après avoir amélioré les méthodes de mesures des micro-benchmarks, Victor Stinner nous propose cette fois d'améliorer la précision des mesures de temps en Python.

    La PEP 564 introduit la gestion des nanosecondes dans le module time. La précision des horloges dans les systèmes d'exploitation modernes peut excéder la précision du nombre flottant de secondes retourné par la fonction time.time(), ainsi que ses différentes variantes.

    Pour éviter la perte de précision, cette PEP ajoute six nouvelles fonctions liées à la précision nanosecondes :

    • time.clock_gettime_ns() ;
    • time.clock_settime_ns() ;
    • time.perf_counter_ns() ;
    • time.process_time_ns() ;
    • time.time_ns().

    Des mesures montrent que la résolution de time.time_ns() est désormais trois fois plus précise que celle de time.time(). Sur la machine utilisée pour les benchmarks, le plus petit intervalle mesuré s'approche des 300 ns sous Windows et fait moins de 100 ns sous Linux.

    Message d'erreur ImportError

    L'erreur ImportError va désormais afficher un message d'erreur plus explicite en affichant le nom du module et le chemin du fichier utilisé lorsque l'expression from ... import ... échoue.

    Concrètement, avec Python 3.6 :

    >py -3.6
    >>> from itertools import toto
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ImportError: cannot import name 'toto'

    Avec Python 3.7, c'est mieux :

    >py -3.7
    >>> from itertools import toto
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ImportError: cannot import name 'toto' from 'itertools' (unknown location)

    PEP 538 : Forçage de la locale C en UTF-8

    La PEP 538 propose d'ajuster le comportement de CPython en présence de la locale C vide ou introuvable. Dans ce cas, CPython se comportera comme si l'environnement était le suivant :

    LC_CTYPE=C.UTF-8
    PYTHONIOENCODING=utf-8:surrogateescape
    

    Un très gros travail a été fait dans le cycle de Python 3 pour attacher un encodage précis à toute chaîne de caractère : dans les noms de fichiers, dans les variables d'environnements, etc. Il reste encore quelques cas subtils, et c'est l'objet de cette PEP rédigée par Nick Coghlan.

    Dans les cas où la locale C est complètement vide, CPython se considérait en ASCII 7 bits et pouvait générer facilement des erreurs de conversion. En forçant l'UTF-8 dans ces situations, CPython devient à même de mieux gérer le problème et de mieux interagir avec les autres modules qui s'attendent tous à travailler en encodage 8 bits. Lorsque CPython réalise cet ajustement, il force la variable d'environnement LC_TYPE ce qui a pour effet important que toutes les bibliothèques chargées dynamiquement depuis l'interpréteur et tous les processus lancés depuis l'interpréteur héritent de ce changement. Cela permet notamment de configurer correctement GNU readline dont le comportement dépend de la locale en cours.

    À l'intérieur de la PEP, Nick liste des cas concrets où cela peut se présenter aujourd'hui et où cette PEP fait la différence :

    • lors de l'utilisation de technologie de conteneurs : Docker, Kubernetes, OpenShift mais aussi GNOME Flatpak ou Ubuntu Snappy ;
    • lors d'un ssh vers un serveur, lorsque la locale du PC initiant la connexion est exportée en tant que variable d'environnement mais n'existe pas sur le serveur.

    Un pas de plus vers l'universalité de l'unicode !

    PEP 540 : Forçage de l'UTF-8 à l'exécution

    La PEP 540 adresse un problème similaire à la PEP précédente, mais avec des cas d'usages légèrement différents. Deux changements sont proposés :

    1. Permettre le forçage de l'utilisation d'UTF-8 par CPython, en ignorant la locale. Ceci peut être activé soit en passant un paramètre au lancement de l'interpréteur ( -X UTF8 ), soit en fixant la variable d'environnement PYTHONUTF8 à 1 ;
    2. Activer ce forçage lorsque la locale est fixée à C (posix). Ceci rejoint le comportement de la PEP précédente.

    Les effets du forçage d'UTF-8 :

    • sys.getfilesystemencoding() retourne systématiquement UTF-8, en ignorant la locale ;
    • locale.getpreferredencoding() retourne systématiquement UTF-8, en ignorant la locale et le paramètre do_setlocale ;
    • sys.stdin, sys.stdout, and sys.stderr utilisent l'encodage UTF-8 avec la gestion d'erreur surrogateescape pour stdin/stdout, backslashreplace pour stderr.

    Ces deux PEP permettent d'ajuster le comportement de CPython lorsque la locale est configurée différemment pour un système. La différence principale entre les deux approches est que le forçage d'UTF-8 n'affecte que l'interpréteur en cours, il n'est pas hérité par les autres modules dynamiques du même environnement ou par les sous-processus lancés. Les deux PEP sont donc complémentaires.

    PEP 552 : Des .pyc basés sur les hash

    La compilation des modules python en bytecode est stockée dans un fichier <nom du module>.pyc dans le répertoire __pycache__. En informatique, lorsqu'on parle de cache, il se pose toujours la question délicate de l'invalidation du cache et Python ne fait pas exception. Python a choisi jusqu'à présent de stocker des tampons de date (timestamp) dans le .pyc. Lors de l'exécution, l'interpréteur regarde la date de modification du module Python, la date stockée dans le .pyc et si cette dernière est plus ancienne, il recompile le module. L'approche a plutôt bien marché pour les 24 dernières années, mais il se trouve des cas où ce n'est pas approprié :

    1. lorsque le tampon de date des fichiers n'est pas complètement fiable ou précis (salut NFS, salut les partages réseaux Windows !) ;
    2. lorsqu'on veut créer des builds reproductibles, c'est-à-dire construire un logiciel de façon à ce que pour des données d'entrées identiques, les données de sorties soient identiques. Faire dépendre le choix de recompiler un module d'une date de modification d'un fichier altère cette reproductibilité.

    La solution proposée et implémentée par la PEP 552 est de stocker un hash du fichier source dans le .pyc, en lieu et place du tampon de date. L'algorithme de hash choisi est SipHash, parce qu'il est déjà disponible dans l'interpréteur.

    L'interpréteur CPython ne générera spontanément jamais de .pyc basé sur les hashes. Pour obtenir de tels .pyc, il faut déclencher soi-même la compilation avec les modules compileall ou py_compile.

    Deux types de .pyc basés sur les hashes ont été définis :

    • les vérifiés, pour lesquels CPython va recalculer le hash du module source et vérifier si un changement a eu lieu ;
    • les non-vérifiés, pour lesquels CPython se contente de charger le module. Cela correspond à des environnements ou un autre programme est chargé de vérifier et générer les .pyc en fonction de l'évolution des sources.

    PEP 562 : Extension de l'accès aux attributs de module

    Avec la PEP 562, Python 3.7 permet de définir une fonction __getattr__() pour les modules. Cette fonction sera appelée lorsque l'attribut d'un module n'est pas trouvé, selon le même principe que __getattr__() pour les classes. Il est également possible de définir la fonction __dir__() qui sera appelée lorsque l'utilisateur liste le contenu du module (avec dir()).

    Un exemple typique d'usage de ces deux fonctionnalités est la possibilité de gérer l'obsolescence de certaines fonctions du module, ou encore de permettre un chargement à la demande (lazy loading).

    Exemple d'émission de warning pour des fonctions obsolètes :

    # monmodule.py
    from warnings import warn
    deprecated_names = ["old_function", ...]
    
    def _deprecated_old_function(arg, other):
        ...
    
    def new_function():
        ...
    
    def __getattr__(name):
        if name in deprecated_names:
            warn(f"{name} is deprecated", DeprecationWarning)
            return globals()[f"_deprecated_{name}"]
        raise AttributeError(f"module {__name__} has no attribute {name}")
    
    def __dir__():
        return ["new_function"]+ deprecated_names
    
    # main.py
    from monmodule import old_function  # fonctionne, mais émet un warning
    print(dir(monmodule))  # affiche ["new_function", "old_function" ]
    # avant python 3.7, cela aurait affiché ["_deprecated_old_function", "new_function", ...]

    PEP 565 : Meilleure gestion des alertes d'API obsolètes

    Avec la PEP 565, Python 3.7 fait des ajustements à la marge sur la gestion des alertes (warnings) lors de l'usage d'API obsolètes. Une gestion appropriée de ce type d'alerte n'est pas facile à trouver et les développeurs de Python cherchent le bon niveau de compromis.

    Python dispose de trois types principaux d'alertes à lever pour les API qui sont sur le chemin de l'obsolescence :

    • PendingDeprecationWarning : utilisé pour les API qui deviendront prochainement obsolètes ;
    • DeprecationWarning : utilisé pour les API qui sont obsolètes et disparaitront dans le futur ;
    • FutureWarning : utilisé pour les constructions syntaxiques dont la construction va changer dans le futur.

    Ces alertes sont levées sous forme de messages sur la sortie d'erreur mais n'affectent pas le programme outre-mesure. L'étape après DeprecationWarning est de lever une exception, qui cette fois arrête le programme en cours d'exécution.

    Jusqu'à Python 2.6 et 3.1 , le comportement par défaut était de cacher les PendingDeprecationWarning, et d'afficher les autres. Un mode développeur pouvait être activé avec -Wdefault, dans lequel Python affichait aussi les PendingDeprecationWarning, ce mode étant notamment activé par le module unittest.

    L'idée était que les développeurs utilisent le mode -Wdefault, et que les utilisateurs d'un programme ou d'une bibliothèque en Python voient uniquement les FutureWarning et DeprecationWarning.

    À l'usage, les développeurs de Python ont constaté qu'un nombre croissant d'utilisateurs de bibliothèques ou programmes écrits en Python étaient confrontés à des alertes DeprecationWarning, pour lesquelles ils ne pouvaient rien : elles étaient levées par des dépendances de leur code, sur lesquelles ils n'avaient pas de contrôle. Cela correspondait en général à une situation où une bibliothèque avait été validée et livrée avec une version de Python plus ancienne, dans laquelle cette alerte n'existait pas encore.

    La décision a donc été prise pour Python 2.7 et 3.2 d'ignorer les alertes DeprecatonWarning par défaut, tout comme les PendingDeprecationWarning. Il faut activer le mode -Wdefault pour revoir ces deux types d'alertes.

    Cependant, ce changement a rendu ces alertes trop discrètes et des développeurs ont été surpris de la disparition de certaines API dans de nouvelles versions de Python alors que leur disparition avait été préparée.

    La PEP 565 propose un compromis plus subtil pour gérer la situation : afficher les DeprecationWarning lors de l'exécution du module principal. Le module principal s'entend comme le module __main__ pour un script d'un seul fichier ou le code entré dans l'interpréteur interactif.

    D'autres changements plus légers sont inclus dans cette PEP :

    • la signification de FutureWarning est étendue aux alertes destinées aux utilisateurs d'une application, pour les prévenir d'une utilisation en passe de devenir obsolète (on peut imaginer par exemple un réglage particulier d'une application qui n'a plus de sens) ;
    • la documentation sur les alertes devient beaucoup plus détaillée, avec la liste complète des options en ligne de commande pour les contrôler, le détail du filtre par défaut et pas mal d'exemples pour montrer comment tester la génération des warnings ;
    • il y a maintenant une recommandation officielle à destination des développeurs d'outils de tests, d'activer les alertes développeur lors de l'exécution d'une suite de tests ;
    • de même, les développeurs de ligne de commande interactive (shell), tel que par exemple IPython, sont priés de configurer les alertes afin d'afficher les DeprecationWarning pour les commandes entrées interactivement.

    Le nouveau mode d'exécution « dev »

    La ligne de commande a maintenant une option en plus, -X dev qui active le mode développement de CPython (également activable via la variable d'environnement PYTHONDEVMODE). Dans ce mode, CPython réalise des vérifications supplémentaires à l'exécution, qui sont trop consommatrices pour être activées par défaut :

    • affichage de tous les types d'alertes (y compris le DeprecationWarning cité plus haut) ;
    • activation des traceurs mémoires pour les allocations, cf PyMem_SetupDebugHooks() ;
    • activation du module faulthandler qui permet d'afficher la pile d'appel lors d'un crash ;
    • activation du mode debug de asyncio.

    Amélioration de l'API C :

    PEP 539 : Introduction d'une nouvelle API C pour le stockage interne à un thread

    La PEP 539 propose une nouvelle API pour le stockage de données privées pour un thread (Thread Local Storage ou TLS). Il existait déjà une telle API dans CPython, mais celle-ci souffrait du problème suivant : la clé utilisée pour chercher des valeurs spécifiques à un thread était un int. C'est contraire à la norme POSIX pthreads, qui exige un type opaque pthread_key_t. Cela n'est pas un problème pour les plate-formes où le type pthread_key_t peut se convertir facilement en int, comme Linux (où c'est un unsigned int) ou Windows (où c'est un DWORD). Cependant, d'autres plate-formes existent, qui sont compatibles POSIX, et pour lesquelles l'API existante ne peut pas fonctionner : Cygwin et CloudAPI par exemple.

    L'API actuelle de stockage interne à un thread est donc marquée en tant qu'obsolète et une nouvelle API compatible POSIX la remplace.

    Communauté

    PEP 545 : Officialisation des traductions de la documentation

    La PEP 545 décrit le processus de traduction de la documentation Python. Trois traductions sont désormais hébergées sur python.org :

    La PEP permet de mettre en valeur les efforts fait par différentes communautés pour traduire la documentation, et permettra d'uniformiser le travail fait sur d'autres langues : espagnol, chinois, etc.

    On en profite pour faire appel à des contributeurs : la traduction française est aujourd'hui à 29 % et pourrait recevoir plus de contributeurs. Ça se passe sur GitHub.

    Liens complémentaires

    Toutes les nouvelles PEP introduites :

    • PEP 538 : Force l'utilisation du locale C historique à un locale UTF-8.
    • PEP 539 : Nouvelle API C pour ajouter une mémoire locale de thread, ou Thread Local Storage (TLS).
    • PEP 540 : Ajout d'un nouveau mode UTF-8
    • PEP 545 : Officialisation du processus de traduction de la documentation
    • PEP 552 : Reproductibilité des fichiers .pyc
    • PEP 557 : Introduction des dataclasses
    • PEP 560 : Gestion dans le cœur de Python du module typing et des types génériques
    • PEP 562 : Extension de l'accès aux attributs de module
    • PEP 563 : Évaluation différée des annotations
    • PEP 564 : Gestion des nanosecondes pour le module time
    • PEP 565 : Meilleure gestion des alertes d'API obsolètes
    • PEP 567 : Variables contextualisées

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Monday 10 September 2018 - 17:29

    La revue de presse de l'April est régulièrement éditée par les membres de l'association. Elle couvre l'actualité de la presse en ligne, liée au logiciel libre. Il s'agit donc d'une sélection d'articles de presse et non de prises de position de l'association de promotion et de défense du logiciel libre.

    Sommaire

    [ZDNet France] De l'open source dans vos projets informatiques? Quelle idée!

    Par Leslie Saladin, le samedi 8 septembre 2018. Extrait:

    Les raisons de l'expansion des solutions open source, leurs atouts et leur succès en France: une tribune de Leslie Saladin, de BlueMind.

    Lien vers l'article original: https://www.zdnet.fr/blogs/l-esprit-libre/de-l-open-source-dans-vos-projets-informatiques-quelle-idee-39873337.htm

    Et aussi:

    [ouest-france.fr] La Baleine, un lieu alternatif pour créatifs et bricolos

    Par Nelly Cloarec, le samedi 8 septembre 2018. Extrait:

    Plutôt que de bosser dans leur salon, une vingtaine d’artistes trouvent refuge à La Baleine, à Quimper. Ils y partagent les mètres carrés, les outils et les idées.

    Lien vers l'article original: https://www.ouest-france.fr/bretagne/quimper-29000/quimper-la-baleine-un-lieu-alternatif-pour-creatifs-et-bricolos-5956282

    Et aussi:

    [L'OBS] La directive sur le droit d'auteur inquiète la fondation Wikimedia

    Par Thierry Noisette, le mercredi 5 septembre 2018. Extrait:

    La fondation américaine qui soutient Wikipédia met en garde contre un risque d'atteinte au partage et de réduction du domaine public avec le texte qui sera voté le 12 septembre.

    Lien vers l'article original: https://www.nouvelobs.com/economie/20180905.OBS1856/la-directive-sur-le-droit-d-auteur-inquiete-la-fondation-wikimedia.html

    Et aussi:

    Voir aussi:

    [We Demain] Dominique Hubert, conseiller en informatique "éthique"

    Par Emmanuelle Vibert, le mercredi 5 septembre 2018. Extrait:

    Deuxième volet de notre série sur les indépendants qui inventent une nouvelle forme de travail… voire de démocratie.

    Lien vers l'article original: https://www.wedemain.fr/Dominique-Hubert-conseiller-en-informatique-ethique_a3529.html

    [ZDNet France] Linux: Linus Torvalds ne veut plus tout contrôler

    Par Louis Adam, le mercredi 5 septembre 2018. Extrait:

    Linus Torvalds est revenu sur son rôle au sein de l’équipe de développement du kernel Linux à l’occasion de l’Open Source Summit. L’occasion pour lui d’expliquer qu’il n’est pas omniscient et que si le développement se poursuit, c’est avant tout grâce à la communauté des mainteneurs.

    Lien vers l'article original: https://www.zdnet.fr/actualites/linux-linus-torvalds-ne-veut-plus-tout-controler-39873205.htm

    [Contrepoints] Logiciels libres: partage et plaisir

    Par Marien Fressinaud, le lundi 3 septembre 2018. Extrait:

    Si certains logiciels libres sont réputés à la fois pour leur efficacité et leur esthétique fonctionnelle (qu’on nommera design, parce que c’est ainsi), il faut reconnaître qu’ils ne font pas la majorité.

    Lien vers l'article original: https://www.contrepoints.org/2018/09/03/324110-logiciels-libres-partage-et-plaisir

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Tuesday 11 September 2018 - 10:25

    Le Frido 2018 est un livre libre de mathématique destiné à l'agrégation et plus. Il suppose connue la théorie des ensembles, puis fait tout en détail de la constructions des ensembles de nombres jusqu'aux statistiques en passant par les corps, les groupes, l'analyse, les probabilités et un peu de numérique.

    Sommaire

    Logique mathématique et pédagogique

    Le Frido suit la logique mathématique, pas la logique pédagogique. Il n'est donc pas un bon ouvrage pour découvrir la mathématique. Bien que Le Frido parte des bases (construction des ensembles de nombres) et démontre tout en détail, il est destiné aux lecteurs qui savent déjà pas mal de choses.

    J'utilise un script qui vérifie si tous les \ref pointent vers des \label se trouvant plus haut dans le texte, afin de m'assurer qu'aucune notion n'est utilisée avant d'être définie.

    Cette façon de faire pose de grosses contraintes sur la table des matières. Par exemple, remarquez que

    • les coordonnées polaires demandent les fonctions trigonométriques
    • les fonctions trigonométriques demandent de la théorie sur les suites et séries de fonctions
    • le théorème de permutation de limite de fonctions et de dérivée demande une intégrale (ça c'est un truc dingue, et si quelqu'un sait comment faire sans, je suis preneur).

    Donc les coordonnées polaires doivent arriver bien après les intégrales. En particulier, les exemples de changement de variables dans les intégrales durant le chapitre sur les intégrales sont très limités.

    Changements depuis Le Frido 2017

    Par rapport à l'année passée, les principales modifications sont des clarifications et des retours sur les bases. Peu de nouvelles choses pouvant être qualifiées de «woaw un développement de plus».

    • Correction d'erreurs par cdrcprds : Z est intègre et euclidien.
    • Beaucoup de corrections et de précisions dans la partie «théorie des ensembles» par Guillaume Deschamps
    • Unicité du corps de décomposition et nombreuses autres choses autour des anneaux et corps de polynômes grâce aux remarques de cdrcprds.
    • Correction d'une faute dans la définition de la limite ; j'avais recopié trop rapidement la définition fausse très discutable fausse donnée sur Wikipédia : lisez la page de discussion
    • Début de la démonstration du théorème de Weinersmith (qui dit que Lp est un Hilbert si et seulement si p=2). Le nom de ce théorème est de moi, en hommage à la constance de Weiner, décrite dans une section à la fin du Frido.
    • Définition de a^x pour tout a>0 et x\in R, démonstration des principales propriétés, lien avec l'exponentielle et son équation différentielle.
    • Démonstration du fait que les coordonnées polaires sont un difféomorphisme de classe C^{\infty}. Cela via un looooong détour par les produits tensoriels.

    Pour plus de détails, voir le journal des changements. La section «remerciements» dans l'introduction liste les personnes et leurs contributions.

    Contributeurs

    Merci à tout le monde

    Pas mal de monde a envoyé des patch via github et encore plus par mail privé. Merci à tous.

    J'en profite pour réitérer mon appel : si vous avez fait du travail sur le Frido, n'hésitez pas à ajouter votre nom à la liste des contributeurs… ou à me demander de le faire si vous ne touchez pas LaTeX/git.

    Contributions

    Le Frido contient dans son introduction une liste de questions encore en suspens, et de choses à faire. Il y en a pour tous les niveaux en analyse, en algèbre, en numérique et en LaTeX.

    Si vous trouvez des erreurs ou des choses pas claires, n'hésitez pas à m'écrire. Pas besoin de connaître git ou LaTeX : un simple mail suffit.

    Informatique théorique

    Le contenu du Frido est évidemment influencé par mes goûts personnels.

    La partie « analyse » contient quelque morceaux qui dépassent le cadre du programme de l'agrégation, par exemple

    • la mesure de Lebesgue sur R^n est complètement définie, avec sa tribu et tout et tout,
    • la topologie sur les espaces de distributions,
    • certaines versions du théorème de représentation de Riez sont démontrées, et ça va aller empirant parce que j'ai dans l'intention de prouver le théorème de Weiner.

    Les parties « algèbre » et surtout « géométrie » par contre restent au ras du programme (et je ne sais presque pas ce qu'est un espace affine).

    Pourquoi je raconte ça ?

    Parce que le Frido a absolument envie d'avoir une partie solide sur l'informatique théorique. Si vous avez des compétences, n'hésitez pas à rédiger un chapitre ou deux ou plus. Ou plus modestement, rédiger la définition d'une machine de Turing et donner deux exemples serait déjà pas mal.

    Mais attention : le Frido est un cours de mathématique ; la structure reste "définition, théorème, démonstration, exemples" dans cet ordre là.

    Si vous voulez des idées, le programme spécifique à l'option D est vers la fin du programme

    Pour compiler chez vous

    La compilation du document est simplifiée. Il n'y a plus qu'une seule dépendance en un module python personnel.

    Les instructions sont ici.

    Extension

    Le Frido est la partie en français contenant la mathématique de niveau « jouable à l'agrégation ». Si vous en voulez plus, vous pouvez lire mazhe qui contient en plus, en anglais :

    • Ce que j'ai fait pour ma thèse : déformation par action de groupe de AdS vu comme quotient de SO(2,n).
    • Un peu de géométrie non-commutative
    • Une construction assez détaillée des différents types de fibrés (vectoriels, principaux et associés), algèbres de Clifford et opérateur de Dirac au programme.
    • Une tentative de réponse aux questions que je me pose sur la théorie (quantique) des champs : pourquoi le groupe de la nature est SL(2,C) et non Lorentz ? Pourquoi les fermions sont des sections de fibrés associés alors que les bosons sont des connexions ? Plus généralement, que veulent dire les physiciens quand ils disent « ce champ se transforme comme ceci ou cela » ?

    Envoi

    À septembre 2019 pour une prochaine version. En attendant, vous pouvez lire la dernière version roulante et consulter l'erratum mis à jour à chaque découverte désagréable.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Friday 14 September 2018 - 16:56

    ConFoo 2019 se déroulera du 13 au 15 mars à Montréal, à l’Hôtel Bonaventure.
    ConFoo est à la recherche de professionnels ayant une connaissance approfondie du développement avec PHP, Ruby, Java, DotNet, JavaScript, les bases de données, l’intelligence artificielle et plus, souhaitant partager leurs connaissances et expériences lors du prochain ConFoo. Soumettez vos propositions avant le 24 septembre.

    Logo ConFoo 2019

    Nous prenons grand soin de nos conférenciers en couvrant la majorité des dépenses incluant le déplacement, l’hébergement, le déjeuner, le billet complet de la conférence, etc.
    Les présentations sont d’une durée de 35 min + 10 min de questions et peuvent être tant en français qu’en anglais. ConFoo est un environnement ouvert où tout le monde est invité à soumettre. Vous êtes qualifié et amical ? Joignez‐vous à nous !

    Si vous voulez simplement assister à la conférence, nous avons un rabais de 320 US$ en vigueur jusqu’au 21 octobre.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Friday 14 September 2018 - 17:21

    Datafari est une solution de recherche pour entreprise. Elle permet aux employés de retrouver les données où qu’elles soient, quelles qu’elles soient, en sécurité. Plus concrètement, Datafari récupère et indexe les données et documents depuis de nombreuses sources différentes et plusieurs formats de fichiers, et permet de chercher aussi bien à l’intérieur des documents que dans leurs métadonnées.

    Datafari est disponible en version open source, appelée Datafari Community Edition, et en version propriétaire, appelée Datafari Enterprise Edition. Mais comme nous sommes ici sur LinuxFr.org, nous allons nous concentrer sur la version libre ! Celle‐ci est en licence Apache v2 pour limiter les contraintes de réutilisations (même si ça se peut se débattre).

    Que peut‐on faire avec Datafari ?

    Comme dit plus haut, c’est un moteur de recherche pour entreprise. Ses objectifs sont différents d’un moteur de recherche Web, et les défis techniques diffèrent. Pour un moteur de recherche pour entreprise, il faut être multi‐source, multi‐format, et gérer la sécurité. En outre, il faut permettre l’administrer l’outil. Dans la version libre, on peut, côté admin :

    1. administrer les connecteurs aux sources de données vers de nombreuses sources (nous utilisons Apache ManifoldCF avec tous ses connecteurs) dont Sharepoint, Documentum, Alfresco et les partages de fichiers ;
    2. gérer l’algorithme de pertinence qui classe les documents pour leur affichage suite à une requête ;
    3. mettre en avant des documents pour des requêtes identifiées ;
    4. créer des utilisateurs et leur assigner des rôles ;
    5. voir des statistiques d’usage de l’outil ;
    6. créer l’équivalent de Google AdWords (appelés promoliens) ;
    7. gérer des synonymes ;
    8. plein d’autres choses accessibles depuis la documentation confluence.

    Côté utilisateur, on peut :

    1. chercher de façon simple ou avancée ;
    2. bénéficier de la correction orthographique et de l’auto‐complétion ;
    3. utiliser des facettes pour filtrer les résultats ;
    4. mettre des résultats dans un panier de favoris ;
    5. créer des alertes par courriel quand des documents modifiés ou nouveaux correspondent à une requête.

    Sur quoi se base Datafari ?

    On retrouve dans Datafari 4.1 :

    1. Elasticsearch, Logstash et Kibana, pour les tableaux de bord d’Analytics ;
    2. Apache Manifoldcf Postgre et Tomcat), pour le crawl ;
    3. Apache Tika, pour l’analyse du contenu ;
    4. Apache Solr, le moteur d’indexation et de recherche « scalable » big data ;
    5. Apache Cassandra, pour stocker les infos des utilisateurs ;
    6. Ajaxfrancelabs, pour l’interface utilisateur en HTML5/AJAX.

    Comment démarrer ?

    Pour démarrer tout de suite, le mieux est sans doute de suivre le Quick start guide. Pour aller plus loin, il suffit de se balader sur la documentation Datafari sur Confluence, qui couvre les usages, l’administration et le développement.

    Des commentaires ?

    Nous sommes en permanence à l’écoute des commentaires et suggestions pour faire avancer le produit, alors profitez‐en, que ce soit d’un point de vue technique ou fonctionnel, ça nous intéresse. Ah, et si vous êtes déjà un utilisateur, n’hésitez pas à en parler sur le Web !

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Sunday 16 September 2018 - 19:22

    Dans une précédente dépêche nous annoncions les rencontres SPIP du 27 au 30 septembre prochain.

    Comme tous le monde ne connaît pas nécessairement SPIP, et que certaines personnes ont peut‐être juste envie de le découvrir, une journée spéciale « Portes ouvertes » a été prévue : pour venir juste rencontrer la SPIP team, poser quelques questions autour de SPIP et de l’avenir du Web participatif, découvrir les réalisations et projets les plus excitants et, éventuellement, tenter de déboguer un morceau de code avec SPIP qui te pose problème.

    A priori le programme global est :

    • ateliers, conférences et rencontres le matin ;
    • pique‐nique le midi ;
    • ateliers, conférences et rencontres l’après‐midi ;
    • barbecue le soir (et poursuite des présentations, travaux et discussions).

    Les repas sont prévus en mode auberge espagnole / repas canadien : les personnes apportent à manger pour partager.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Monday 17 September 2018 - 00:40

    Le 13 septembre, la mission Etalab lance l’appel à candidature de la troisième promotion de son programme Entrepreneur·e d’Intérêt Général (EIG).

    Le but du programme : recruter cinq designers (femmes ou hommes), neuf développeuses ou développeurs et 18 data scientists, pour relever des défis d’utilité publique au sein de ministères et d’administrations centrales pionnières.

    Le programme recrute (CDD de dix mois, 4 000 euros nets par mois) des candidates ou candidats avec une certaine expérience — environ cinq ans — et des profils moins expérimentés ayant déjà démontré un fort esprit d’entreprise (projets d’entreprenariat, engagements associatifs).

    Tous les défis EIG sont l’occasion de développer des logiciels libres au sein de l’administration.

    Allez voir le site EIG pour plus d’informations sur les profils recherchés !

    Un événement de présentation des défis se tiendra le 3 octobre au Liberté Living Lab (Paris).

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Monday 17 September 2018 - 13:01

    L’édition 2018 du Capitole du Libre se tiendra cette année les samedi 17 et dimanche 18 novembre à l’ENSEEIHT de Toulouse. Le Capitole du Libre est un événement gratuit et libre d’accès consacré aux logiciels libres et à la culture libre. Organisé par l’association Toulibre avec l’aide des clubs étudiants de l’ENSEEIHT (Net7, TVn7 et CAn7), il est orienté à la fois vers le grand public et le public spécialisé.

    Des conférences et des ateliers auront lieu tout au long du week‐end ; des stands et des animations seront proposés au public pour leur faire découvrir le monde du Libre.

    L’appel à participation, ouvert à tous et à toutes, est prolongé jusqu’au 25 septembre 2018 à 23 h 59 (heure de Toulouse), vous pouvez proposer une conférence ou un atelier (ou les deux) sur https://participez-2018.capitoledulibre.org/cfp/. Jusqu’au 31 octobre, il est également possible de demander un espace pour un stand associatif/communautaire.

    Bannière

    Libristes d’Occitanie et d’ailleurs, n’hésitez pas à faire circuler l’information et éventuellement à proposer une intervention.

    Commentaires : voir le flux atom ouvrir dans le navigateur

  • Monday 17 September 2018 - 13:30

    Calendrier Web, regroupant des événements liés au Libre (logiciel, salon, atelier, install party, conférence), annoncés par leurs organisateurs. Voici un récapitulatif de la semaine à venir. Le détail de chacun de ces 46 événements (1 en Belgique, 29 en France, 0 au Luxembourg, 16 au Québec, 0 en Suisse et 0 en Tunisie) est en seconde partie de dépêche.

    SQIL

    Sommaire

    [CA-QC Montréal] Non-conférence WikiSuite - Du vendredi 7 septembre 2018 à 09h00 au mercredi 19 septembre 2018 à 17h00.

    La première non-conférence WikiSuite.

    WikiSuite est la suite intégrée de logiciels libres la plus complète à avoir été développée jusqu'à ce jour. L'ensemble permet de satisfaire les besoins logiciels des entreprises et organisations (vente en ligne, gestion des connaissances, gestion d'événements, gestion du soutien à la clientèle, intranet collaboratif, etc.). WikiSuite est composé notamment de ClearOS, Tiki Wiki CMS Groupware, Openfire Meetings, Syncthing, Elasticsearch, Kimchi et Xibo.

    Une partie de cet événement aura lieu pendant la Semaine québécoise de l'informatique libre (SQiL) 2018.

    [FR Lyon] Rencontre wikimédienne - Le lundi 17 septembre 2018 de 18h30 à 20h00.

    Rencontre mensuelle de la cabale de la quenelle (groupe wikimédien lyonnais).

    Discussion des projets et collaborations en cours ou à venir autour d’une boisson.

    Rejoignez nous

    [FR Grenoble] Atelier cartographie – Initiation OpenStreetMap - Le lundi 17 septembre 2018 de 18h30 à 21h00.

    Le collectif “OpenStreetMap Grenoble” vous propose de vous initier à Open Street Map lundi 17 septembre Cette soirée sera dédiée à l’accueil des contributeurs débutant(e)s
    Venez découvrir comment contribuer à OSM

    Programme

    • Présentation d’OSM,
    • Utiliser les données OSM,
    • Fabriquer une carte personnalisée avec uMap.

    Il est conseillé aux participants de se créer préalablement un compte sur OpenStreetMap, et d’installer JOSM sur leurs ordinateurs.

    A partir de 18h30 à La Coop-Infolab. 31 rue Gustave Eiffel – 38000 Grenoble

    Je m'inscris

    gratuit, sur inscription

    [CA-QC Trois-Rivières] SQiL - Introduction à PureData - Le lundi 17 septembre 2018 de 09h00 à 16h30.

    Dans le cadre de la Semaine québécoise de l’informatique libre (SQiL), Ellektro Lab vous invite à découvrir le logiciel PureData ce lundi 17 septembre de 9h à 16h30 au 1930 rue Bellefeuille.

    Apprenez les diverses applications de ce logiciel de programmation en temps réel utilisé dans la création d’installations vidéos et sonores. Les participants pourront voir et comprendre comment fonctionne le logiciel dans une ambiance de discussion ouverte sur l’utilisation du logiciel en général. Vous pouvez apporter votre ordinateur portable toutefois les places pour s’installer seront limitées afin d’accueillir le plus de gens possible.

    Vous verrez dans cette journée comment créer des effets visuel avec Gem, communiquer avec d’autres interface en utilisant le protocole OSC et comment entrer en interaction avec des éléments physique à l’aide du microcontrôleur Arduino. Pas besoin d’avoir une connaissance en la matière, la conférence se veut plutôt démonstrative que sous forme de cours. C’est l’occasion de mieux comprendre comment intégrer des technologies peu coûteuse dans un contexte artistique ou même pratique.

    Cette activité est gratuite et présentée dans les locaux d’Enigma (1930 rue Bellefeuille à Trois-Rivières, au même endroit qu’Ellektro Lab mais au deuxième étage).

    Consulter la page ellektrolab.com pour plus de détails.

    [CA-QC Montréal] SQiL - (3L)-Logiciels Libres en liberté - Le lundi 17 septembre 2018 de 13h30 à 17h45.

    En septembre 2018 ce sera le 17 prochain, de 13:30 à 17:40. Au Rond-point café autogéré, 3213 Ontario Est, Montréal. Pour notre participation annuelle à la SQiL (Semaine québecoise de l’informatique libre), la MULLM et 3L organisent 2 rencontres pour tous les niveaux d’utilisateurs mais surtout pour les débutants par la présentation de systèmes d’exploitation libres de niveau débutant comme Elementary OS 4.1 Loki ou DFLinux (debian facile linux) strech 9.5.

    Et le vendredi le 21 septembre 2018 de 13:30 à 20:45 pour une seconde chance de voir nos présentations uniques à Montréal car nous y sommes l’unique groupe d’utilisateurs (GULL) dans la grande région de Montréal.

    Amener vos portables, téléphones intelligents et tablettes et votre bonne humeur. Venez jaser sur les logiciels libres, nous montrer vos découvertes, poser vos questions.

    Guy Bernard, fondateur

    Organisateur principal et porte-parole

    Alias Lou P. DeVille, LoupDeVille

    [CA-QC Montréal] SQiL - Rencontre Elastic à propos de Kibana, du nouveau dans la suite 6.x et l'intégration dans WikiSuite - Le lundi 17 septembre 2018 de 18h30 à 21h00.

    Participez à la rencontre avec l'entreprise Elastic (Elasticsearch, Logstash, Kibana et Beats) organisée en collaboration avec WikiSuite le lundi soir 17 septembre à l'espace multifonctionnel Code & Café.

    Au programme de la soirée

    18h30 - Accueil (nourriture et boisson dispo.)
    - Introduction aux nouveautés de Kibana
    19h30 - Les nouveautés de la suite Elastic 6.x, incluant la version 6.3 qui ajoute de nouvelles fonctionnalités (les rollups et le support SQL) à Elasticsearch et la libération du code de X-Pack.
    20h00 - Comment Elasticsearch est utilisé dans WikiSuite

    Cet événement se déroule dans le cadre de la Semaine québécoise de l'informatique libre (SQiL) 2018 et de la première non-conférence WikiSuite.

    Join us for an Elastic (Elasticsearch, Logstash, Kibana, and Beats) meetup with WikiSuite

    7:30 pm - What's new in Elastic Stack 6.x, including the latest release of 6.3 with features like Rollups, SQL support for Elasticsearch, and the opening of X-Pack
    8:00 pm - How Elasticsearch is used in WikiSuite

    This event is taking place in the Semaine québécoise de l'informatique libre (SQiL) 2018 and the first WikiSuite Unconference.

    [FR Nantes] Rencontres Régionales du Logiciel Libre - Le mardi 18 septembre 2018 de 09h00 à 18h00.

    C’est un concept d’événements qui se déroulent à travers toute la France sous l’égide du Conseil National du Logiciel Libre (CNLL) qui a pour but de promouvoir le logiciel libre ainsi que l’écosystème numérique local en fédérant les associations nationales de chaque grande ville.

    A Nantes, elles sont organisées par l’association Alliance Libre dans l’objectif de faire rencontrer des administrations, collectivités, industries et entreprises ayant ou souhaitant déployer des solutions libres avec des prestataires locaux.

    Cette journée permet également aux prestataires de rencontrer de nouveaux talents.

    Cette année, les RRLL 2018 ont lieu dans les locaux d'OVH, quartier EuroNantes. 

    Les inscriptions http://rrll.alliance-libre.org/rencontres-regionales-du-logiciel-libre/inscription

    [FR Grenoble] Install Party - Le mardi 18 septembre 2018 de 19h00 à 22h00.

    Le but de cette rencontre est que les novices repartent à la fin de la journée avec leur propre ordinateur fonctionnant sous un nouveau système d'exploitation, correctement installé, configuré et agrémenté de
    nombreux logiciels.

    Au cours de ces réunions, les utilisateurs confirmés tentent de transmettre une partie de leur savoir aux novices, qui deviendront passeurs à leur tour. (Wikipédia ©)

    [FR Digne-les-Bains] Soirée Linux - Le mardi 18 septembre 2018 de 20h00 à 23h59.

    Linux Alpes vous accueille ce mardi 18 septembre pour sa soirée de rentrée à Digne-les-Bains.

    Discussions sur les logiciels libres, entraide, présentation de logiciels, démonstrations …

    Rendez-vous dès 20H chez Xsalto, voir plan d'accès

    https://umap.openstreetmap.fr/fr/map/linux-alpes_99925#19/44.09325/6.23486

    Contact 06 66 45 80 95

    Entrée libre et gratuite

    [CA-QC Internetville] SQiL - Journée internationale contre les DRM - Le mardi 18 septembre 2018 de 00h00 à 23h59.

    Aujourd'hui, le mardi 18 septembre 2018, est la Journée internationale contre les DRM.

    La Free Software Foundation (FSF) et plusieurs autres organisations dont FACiL au Québec vous invitent à manifester contre les menottes numériques (DRM) qui restreignent l'usage des œuvres culturelles comme les livres, les albums de musique, les films, etc.

    Pour savoir comment vivre sans menottes numériques et protester contre le fléau des DRM, voyez le dossier DRM et droit d'auteur du Wiki de FACiL ou le site officiel (en) de la journée internationale proposée par la FSF dans le cadre de sa campagne «Defective By Design».

    [CA-QC Trois-Rivières] SQiL - Qu’est-ce que le Arduino - Le mardi 18 septembre 2018 de 09h00 à 16h30.

    Dans le cadre de la Semaine québécoise de l’informatique libre (SQiL), Ellektro Lab vous invite à cette conférence où nous démystifierons le Arduino et ainsi découvrir les récentes technologies utilisées par plusieurs artistes en arts numériques. Cette conférence aura lieu le mardi 18 septembre de 9h à 16h30 au 1930 rue Bellefeuille.

    Le but de cette présentation est de démontrer comment programmer le Arduino et comment utiliser des composantes telle que les senseurs, moteurs, interrupteurs et autres dispositifs afin de créer une interaction avec un objet ou avec l’environnement. La journée se veut surtout informative, vous pouvez apporter votre ordinateur portable toutefois les places pour s’installer seront limitées afin d’accueillir le plus de gens possible.

    En après-midi il y aura une démonstration de quelques applications du Raspberry Pi en lien avec le domaine artistique. Nous verrons ensemble différentes façons d’utiliser le Raspberry Pi et aussi mieux comprendre les forces et les limites de ce petit ordinateur.

    Cette activité est gratuite et présentée dans les locaux d’Enigma (1930 rue Bellefeuille à Trois-Rivières, au même endroit qu’Ellektro Lab mais au deuxième étage).

    [CA-QC Montréal] SQiL - Apportez votre ordi à Koumbit - Le mardi 18 septembre 2018 de 17h00 à 19h00.

    Venez au bureau de Koumbit entre 17h et 19h pour de l'aide personnalisée avec des outils en code libre sur votre ordi. On ne peut pas garantir qu'on sera capable de trouver une solution pour le problème ou défi auquel vous faites face, mais on a hâte d'essayer de vous aider Nous avons de l'expertise en particulier avec les applications Web comme WordPress, Drupal et Nextcloud, ainsi que le système d'opération Debian et les outils qui roulent là-dessus.

    Koumbit est un OBNL fondé en 2004 à Montréal. Autant les individus que les organisations peuvent être membres de Koumbit, tant qu'ielles partagent nos valeurs.

    Notre principale activité est de fournir des services Web, incluant l'hébergement et le développement de sites. Ce travail est accompli par les membres qui forment le Conseil de travail, souverain dans les prises de décisions.

    Koumbit est un fier partisan des groupes communautaires et militants locaux et internationaux. Les choix technologiques que nous proposons sont adaptés aux besoins de ces groupes et construits uniquement avec des logiciels libres.

    Pour en apprendre plus ou pour nous contacter, visitez koumbit.org

    [CA-QC Montréal] SQiL - Soirée de traduction des pages d'aide de Riseup - Le mardi 18 septembre 2018 de 19h00 à 21h30.

    Les pages d'aide de Riseup sont une précieuse source d'information pour améliorer sa sécurité informatique. Elles peuvent être consultées par tout le monde et sont un excellent endroit pour en apprendre plus sur la sécurité en ligne.

    Dans le cadre de la SQiL 2018, nous vous invitons à nous rejoindre pour une soirée de traduction des pages d'aide de Riseup Au menu, traduction de ces pages de l'anglais vers d'autres langues.

    Les pages d'aide de Riseup sont disponibles dans les langues suivantes

    • Français
    • Espagnol
    • Mandarin
    • Portugais
    • Allemand
    • Italien
    • Catalan
    • Hindi
    • Polonais
    • Grec
    • Russe

    Si vous parlez une de ces langues, vous pouvez nous aider à en améliorer la traduction

    Tout le monde est la bienvenue à cet événement. Aucune connaissance technique particulière n'est requise.

    Si possible, pensez à apporter un ordinateur portable avec vous car il n'y aura pas de postes de travail disponibles.

    [FR Le Mans] Permanence mercredi après-midi - Le mercredi 19 septembre 2018 de 12h00 à 17h00.

    Assistance technique et démonstration concernant les logiciels libres.

    [FR Beauvais] Atelier hebdomadaire de partage de connaissances autour des logiciels libres - Le mercredi 19 septembre 2018 de 18h00 à 20h00.

    Chaque mercredi soir, l'association propose une rencontre pour partager des connaissances, des savoir-faire, des questions autour de l'utilisation des logiciels libres, que ce soit à propos du système d'exploitation Linux, des applications libres ou des services en ligne libres.

    C'est l'occasion aussi de mettre en avant l'action des associations fédératrices telles que l'April ou Framasoft, dont nous sommes adhérents et dont nous soutenons les initiatives avec grande reconnaissance.

    L'atelier a lieu en salle 3.

    [FR Paris] Apéro du Libre - Le mercredi 19 septembre 2018 de 19h00 à 23h00.

    Tous les 15 du mois, Parinux vous convie à l'Apéro Parisien du Libre (APL). Cet événement informel et convivial réunit les personnes intéressées par le monde du Libre.

    Pour le 15 septembre, exceptionnellement on a décidé de reporter au 19 septembre, déjà parce que le samedi soir, ce n’est pas pratique de trouver un (bon) bar qui ne soit pas bondé à craquer, ensuite parce qu’un certain nombre d’entre nous ne pouvaient pas être dispos ce jour-là.

    Nous vous donnons donc rendez-vous au Gob le 19/09 à partir de 19h (facile) pour échanger autour du Libre avec les bénévoles de l’association Parinux.

    Tou·te·s sont les bienvenu·e·s, qu'ils/elles soient membres ou non, que ce soit pour découvrir l'association, se renseigner sur ses activités, ou simplement partager un bon moment avec d'autres bénévoles du Libre

    [FR Lyon] Comment construire son centre de console rétro - Le mercredi 19 septembre 2018 de 19h30 à 21h00.

    Atelier connecté 2018-2019 (mercredi 19h30-21h), à partir de 16 ans, animé par  Romain Deville

    Apprenez à manipuler et mettre à votre service les objets connectés.

    Comment construire son centre de console rétro en 3 séances

    Cycles de 3 séances Mercredis 19 septembre, Mercredi 26 septembre, Mercredi 3 octobre 2018

    Dans le Hall de la MPT, vous avez pu découvrir et/ou jouer avec notre borne d’arcade. Lors de ces 3 séances, nous vous apprendrons à réaliser votre propre borne d’arcade afin de jouer en familles ou avec vos amis. N’hésitez plus.
    Pour les plus curieux, cela s’installera sur un Raspberry Pi. (si vous avez le votre n’hésitez pas à venir avec, sinon on vous le fournira).

    Venez nombreux

    [FR Carnac] SGEG - Le mercredi 19 septembre 2018 de 19h30 à 22h00.

    Le SGEG (Sansten GNU Easy Group) vous invite tous les 3 mercredi de chaque mois au SGEG Meeting pour discuter de Logiciel Libre, boire un verre, manger un morceau et surtout se rencontrer

    Ce mois-ci, retrouvez la fine équipe de l'association Rhizomes à Ty Gwelig à Carnac à partir de 19h30.

    Du covoiturage est organisé au départ de Vannes, Auray… N'hésitez-pas à poster un courriel sur la liste de discussion.Le rendez-vous est fixé à 19h30.

    Tous les utilisateurs de Logiciel Libre sont les bienvenus (*BSD, Hurd, GNU/Linux, etc.) ainsi que toutes les associations, les utilisat[eur|trice]s même les non averti⋅e⋅s.

    Prévoir une participation culinaire, nous sommes dans un restaurant.

    Attention, il faut s'inscrire tous les mois Afin d'évaluer le nombre de personnes qui viendront.

    [FR Toulouse] Rencontres Tetalab - Le mercredi 19 septembre 2018 de 20h30 à 23h30.

    Rencontre hebdomadaire des hackers et artistes libristes Toulousains.

    Ouvert au public tous les mercredi soir.

    Venez nombreux.

    [CA-QC Montréal] SQIL - Découvrez le logiciel libre pour un numérique éthique - Le mercredi 19 septembre 2018 de 14h00 à 19h00.

    Dans le cadre de la Semaine québecoise de l'informatique libre, l'équipe de LINAGORA est très heureuse de vous accueillir dans ses locaux de Montréal pour échanger sur le thème du numérique éthique et du logiciel libre durant une après-midi.

    Bigdata, traçabilité, protection des données, … À l'heure où les assistants vocaux fleurissent et où l'IA se révèle de plus en plus intrusive, des moyens colossaux sont déployés par les GAFAM (Google, Apple, Facebook, Amazon et Microsoft) et BATX (Baidu, Alibaba, Tencent, Xiaomi) pour capter toujours plus de données et les valoriser commercialement ou politiquement.

    Quelle sont les solutions pour profiter de ces nouveaux services numériques tout en ayant une attitude citoyenne et responsable

    Nous pensons qu'il faut développer une nouvelle approche d'un numérique fondé sur l'éthique. Or nous constatons bien souvent que l'on parle d'éthique à posteriori, juste après qu'un scandale éclate (Affaire Facebook-Cambridge Analytica par exemple).

    Comment devenir proactif face à ces enjeux et traiter notamment les sujets de protection des données à priori

    Chez LINAGORA nous croyons de tout coeur que les réponses sont dans l'open source

    Au programme de cette après-midi d'échange

    • Présentation de l'innovation de LINAGORA pour un monde libre et de nos solutions pour protéger vos données et faire de l'IA éthique - Baptiste IVOL (LINAGORA)
    • Comment quitter les services GAFAM (Personnels & Professionnels) ? - Fabien Rodriguez (Le Goût du Libre)
    • Économie sociale et solidaire s'affranchir des logiciels fermés - Professeur Louis Martin (titulaire de la Chaire de recherche de logiciel libre, Finance sociale et solidaire)
    • Mot de clôture - François-William Croteau (Membre du comité exécutif, Responsable de la ville intelligente, des technologies de l'information et de l'innovation et de l'enseignement supérieur
    • Cocktail de réseautage

    Pour en savoir plus sur notre société

    LINAGORA est l'un des éditeurs de logiciels libres les plus innovants au monde et s'est donné il y a 18 ans la mission de permettre aux organisations publiques et privées de développer leur indépendance technologique. (Plus…)

    [CA-QC Montréal] SQiL - Grande conf. sur les politiques publiques d'Internet - Le mercredi 19 septembre 2018 de 16h30 à 19h00.

    IMPORTANT l'inscription est gratuite mais obligatoire vu le nombre limité de places

    Titre de la conférence Les politiques publiques d'Internet. Des réseaux libres, neutres, décentralisés, qui nous appartiennent en commun

    Conférencier Alexis Fitzjean O'Cobhthaigh de La Quadrature du Net (Paris)

    Description 2018 aura vu la fin du principe de la neutralité du réseau Internet aux États-Unis, principe attaqué à plusieurs reprises par des géants des télécommunications depuis 2004. Quelques années plus tôt, Chelsea Manning et Edward Snowden nous révélaient toute l'étendue de la collecte, du pistage et du profilage des internautes au service des États d'une part et au profit des géants du numérique d'autre part. Doit-on s'inquiéter pour l'avenir d'Internet Au fait, quel est l'état des politiques publiques relatives à Internet au Québec/Canada Est-ce mieux ailleurs, par exemple en Europe, là où des États comme la France commencent à mettre en application un nouveau Règlement général sur la protection des données (RGPD) ?

    Ajuster nos lois et nos institutions pour tâcher de réparer les dommages et mieux résister aux attaques n'est certainement pas inutile, mais ce n'est pas nous mettre en position de préparer et de maîtriser notre avenir. À plus long terme, qu'est-ce que les citoyens et les citoyennes peuvent faire de mieux pour favoriser le développement d'un réseau des réseaux qui sera véritablement libre, neutre, décentralisé, protecteur de nos libertés et de nos droits et compris comme un bien commun à cultiver pour l’enrichissement de tous, à préserver pour les générations futures

    Voilà quelques unes des questions auxquelles tâchera de répondre notre intervenant dans le cadre de l'édition 2018 de la Grande conférence de la Semaine québécoise de l'informatique libre.

    Rappelons que la Semaine québécoise de l'informatique libre (SQiL) se déroule du 15 au 23 septembre 2018 et que la Grande conférence la SQiL est coorganisée par FACiL et la Chaire Lexum en information juridique.

    Les avocats et les notaires souhaitant recevoir une attestation de participation doivent remplir cet autre formulaire en plus de s'inscrire à l'événement.

    [CA-QC Montréal] SQiL - Introduction à Gutenberg, le nouvel éditeur WordPress - Le mercredi 19 septembre 2018 de 17h00 à 19h00.

    Gutenberg, le nouvel éditeur de WordPress, sera lancé très bientôt Pour aider les utilisateurs.trices de WordPress à gérer ce changement significatif, Koumbit offre un atelier pratique (et gratuit) où les participant.e.s pourront se familiariser avec ce système. Apportez votre ordinateur portable à 17h le mercredi 19 septembre, et un membre du collectif vous guidera à travers le processus pour installer l'éditeur et expérimenter avec ses différentes fonctionnalités.

    Koumbit est un OBNL fondé en 2004 à Montréal. Autant les individus que les organisations peuvent être membres de Koumbit, tant qu'ielles partagent nos valeurs.

    Notre principale activité est de fournir des services Web, incluant l'hébergement et le développement de sites. Ce travail est accompli par les membres qui forment le Conseil de travail, souverain dans les prises de décisions.

    Koumbit est un fier partisan des groupes communautaires et militants locaux et internationaux. Les choix technologiques que nous proposons sont adaptés aux besoins de ces groupes et construits uniquement avec des logiciels libres.

    Pour en apprendre plus ou pour nous contacter, visitez koumbit.org

    [CA-QC Montréal] SQIL - stratégie numérique axée sur les données - Le mercredi 19 septembre 2018 de 17h30 à 20h00.

    Comment tirer profit des algorithmes pour votre stratégie numérique, tout en tenant compte des bonnes pratiques sur la vie privée, telles qu'imposées par le RGPD européen

    Venez faire le plein de nouvelles idées et partager votre expérience avec nos conférenciers mercredi 19 septembre

    Speakers
    - Fares Aldik, Directeur marketing analytique, Adviso
    - Denis Archambault, Partenaire et Chef de Pratique Visualisation avancée des données, DSI Data Science Institute
    - Mohamed Khalfallah, Partenaire et Chef de Pratique Machine Learning/AI, DSI Data Science Institute
    - Vincent Bureau, Gestionnaire de programme conformité RGPD, 360Project

    *Déroulé de la soirée
    *

    5:30 | Ouverture des portes et réseautage
    5:45 | Nouvelles de la communauté, présentation des intervenants et des sponsors
    6:00 | Les données au coeur de l'organisation - Fares Adlik
    6:40 | Mesurer la performance des campagnes numériques dans le monde physique - Denis Archambault
    7:00 | Des actions marketing augmentées par l'IA pour diminuer les taux de désabonnement à un service - Mohamed Khalfallah
    7:25 | RGPD 3 mois après - Vincent Bureau
    7:45 | Questions à nos intervenants et réseautage
    8:00 | Fermeture des portes

    Modalités d'inscription et détails de l'événement sur la page du Meetup

    Attention, cet événement est payant et les places sont limitées

    [FR Digne-les-Bains] Café numérique Logiciel libre, savoirs libres, semences libres, société libre - Le jeudi 20 septembre 2018 de 14h30 à 15h30.

    Jean-Christophe Becquet, directeur d'APITUX et président de l'April animera le prochain Café numérique sur le thème « Logiciel libre, savoirs libres, semences libres, société libre », jeudi 20 septembre 2018 à 14h30 à l'Espace Numérique LUMEN, 45 avenue du 8 mai 1945 à Digne-les-Bains.

    « De l’invention du logiciel libre par Richard Stallman en 1984 à sa diffusion dans toutes les sphères de la société. Cette conférence précisera le fonctionnement des licences libres. Elle développera les enjeux du logiciel libre, notamment dans l’éducation. Elle montrera comment le libre s’est progressivement élargi à toutes les champs de la connaissance avec des projets d’envergure mondiale comme l’encyclopédie Wikipédia ou la carte collaborative OpenStreetMap. Elle explorera enfin la diffusion des mêmes principes de partage à d’autres communs comme les semences végétales. »

    Jean-Christophe Becquet s'implique dans les communautés du logiciel libre depuis 1997. Conférencier, enseignant et formateur, il est habitué à s'adresser à un public non technicien.

    Cet événement s'inscrit dans le cadre de la Fête des possibles à laquelle l'April participe du 15 au 30 septembre 2018.

    [FR Lyon] Le jeudi c'est Wiki où sont les femmes - Le jeudi 20 septembre 2018 de 17h00 à 19h00.

    Enrichissez l'encyclopédie Wikipédia sur les Lyonnaises célèbres et participez à l'organisation des balades urbaines journées du matrimoine à Lyon.

    Contribuer sur Wikipédia c'est facile Enquêtez chaque mois avec le collectif de Wikipédiens et Wikipédiennes lyonnais-es pour enrichir de textes, images et informations tieées du fonds e la Bibliothèque et Internet.

    Ce mois-ci, Participez à l’enrichissement des connaissances sur les femmes qui ont laissé leur empreinte à Lyon en vue de nourrir les balades qui seront organisées lors des journées du matrimoine par l'association Filactions.

    Retrouvez l'ensemble des sessions mensuelles Wikipédia organisées le 3e jeudi de chaque mois à l'EN Part-DIeu sur la page projet Wikipédia.

    Gratuit sur inscription dans la limite des places disponibles (sur place ou au 04 78 62 19 79).

    [FR Montpellier] Aprilapéro - Le jeudi 20 septembre 2018 de 18h45 à 19h30.

    Un apéro April consiste à se réunir physiquement afin de se rencontrer, de faire plus ample connaissance, d’échanger, de partager un verre et de quoi manger mais aussi de discuter sur l’actualité et les actions de l’April.

    Un apéro April est ouvert à toute personne qui souhaite venir, membre de l’April ou pas. N’hésitez pas à venir nous rencontrer.

    Régulièrement Montpel’libre relaie et soutient les actions de L’April. De nombreux Apriliens ont par ailleurs rejoints les rangs de Montpel’libre, sans doute lors d’Apéro April, d’AprilCamp ou des Rencontres Mondiales du Logiciel Libre qui ont eu lieu à Montpellier.

    Nous vous invitons donc à venir nous rejoindre dans une ambiance conviviale, à partager cet apéro, chacun porte quelque chose, boissons, grignotages… et on partage.

    Les Aprilapéro Montpellier ont lieu le 3e jeudi de chaque mois de 18h45 à 19h30.

    Entrée libre et gratuite sur inscription. Une simple adhésion à l’association est possible.

    Cet événement vous est proposé dans le cadre du partenariat qui lie le Do Tank, l’April et Montpel’libre.

    Tramway lignes 1, 2, 3 et 4, arrêts Gare Saint-Roch
    GPS Latitude 43.60285 | Longitude 3.87927

    [FR Lyon] Jeudi bidouille - Le jeudi 20 septembre 2018 de 19h00 à 22h00.

    Atelier gratuit - jeudi 19h00 à 22h00


    L’EPN des Rancy (249, rue Vendôme, 69003 Lyon) et l'association ALDIL (Association Lyonnaise pour le Développement de l'Informatique Libre) vous proposent des rendez-vous mensuels pour accompagner les utilisateurs de logiciel libre dans la résolution de leur problème informatique.

    L'objectif de ces ateliers sont l'entraide et dépannages entre utilisateurs de logiciel libres débutants et plus aguerris. L’occasion de voir comment ça marche, de demander un coup de pouce, de faire découvrir une astuce.

    Avec la participation des bénévoles de l’ALDIL, Illyse et des utilisateurs de GNU/Linux (Ubuntu, Debian, Mageia, LinuxMint…).

    Ces ateliers sont ouverts à tous.

    N'hésitez pas à venir nombreux.

    Rappel aucune installation de logiciel sous licence ne pourra être faite sans présentation de la licence et de sa preuve d’achat. Par défaut, les intervenants proposeront des logiciels libres mais s’adaptent à d’autres demandes.

    [FR Paris] Traduction de la documentation de Python - Le jeudi 20 septembre 2018 de 19h00 à 21h00.

    Cet atelier a pour but d'avancer dans la traduction de la documentation de Python en français.

    Vous présenter les différentes manières et les différents outils pour traduire la documentation de Python, et vous y aider.

    On s'y partagera des pizza sponsorisées par la PSF et on sera hébergés par Budget Insight (Merciiii à eux eux ♥)

    N'oubliez pas de vous inscrire sur meetup pour que je vous compte pour les pizzas.

    [FR Paris] Soirée de Contribution au Libre - Le jeudi 20 septembre 2018 de 19h30 à 22h00.

    Parinux propose aux utilisateurs de logiciels libres de se réunir régulièrement afin de contribuer à des projets libres. En effet, un logiciel libre est souvent porté par une communauté de bénévoles et dépend d'eux pour que le logiciel évolue.

    Nous nous réunissons donc tous les dans un environnement propice au travail (pas de facebook, pas de télé, pas de jeux vidéos, pas de zombies).

    Vous aurez très probablement besoin d'un ordinateur portable, mais électricité et réseau fournis.

    En cas de difficulté, vous pouvez joindre un des responsables de la soirée, Emmanuel Seyman (emmanuel (at) seyman.fr), Paul Marques Mota mota (at) parinux.org, ou Magali Garnero (Bookynette) tresorier (at) parinux.org.

    Pour obtenir le code d'entrée de la porte cochère, envoyez un mail au responsable.

    On peut amener de quoi se restaurer (Franprix, 8 rue du Chemin Vert, ferme à 22h)

    Regazouillez sur Twitter - Wiki des soirées

    Programme non exhaustif

    • Fedora (sa traduction)
    • Parinux, ses bugs et son infrastructure
    • April réunion du groupe de travail sensibilisation de 18h45 à 20h30. Accueil à partir de 18h30
    • Open Food Facts/ Open Beauty Facts, sa base de données, ses contributeurs, sa roadmap
    • Schema racktables, son code
    • Agenda du Libre, mise à jour et amélioration du code
    • Ubuntu-Fr, son orga, ses événements
    • En vente libre, maintenance et commandes
    • Open street map, une fois par mois
    • Linux-Fr sait faire
    • en vente libre

    tout nouveau projet est le bienvenu.

    Tous les 1ers jeudis => Les associations Ubuntu-fr  et ouvre-boite organisent une réunion pour leurs membres.

    Tous les jeudis, le groupe de travail Sensibilisation de l'April se réunit pour réfléchir à mieux communiquer vers le grand public.

    Tous les jeudis, des membres de Framasoft organisent des contrib'atliers et vous invitent à venir participer, tester ou améliorer des logiciels libres

    [FR Vannes] Initiation Inkscape & dessin vectoriel - Le jeudi 20 septembre 2018 de 20h00 à 22h30.

    Une introduction aux principes du dessin vectoriel et à l'interface du logiciel Inkscape, proposée par MakerSpace56 à ses adhérents.

    [FR Toulouse] Repas du Libre - Le jeudi 20 septembre 2018 de 20h30 à 23h00.

    Le groupe d'utilisateurs de logiciels libres de Toulouse Toulibre en collaboration avec Tetaneutral.net fournisseur d'accès internet et hébergeur libre proposent aux sympathisants de se retrouver l'un des mardis ou jeudis de chaque mois pour échanger autour des logiciels libres, des réseaux libres, discuter de nos projets respectifs et lancer des initiatives locales autour du Libre.

    Ce repas est ouvert à tous, amateurs de l'esprit du Libre, débutants ou techniciens chevronnés.

    Ce Qjelt aura lieu le jeudi 20 septembre 2018 à 20h30, au restaurant la Paniolade situé au 146 Boulevard de Suisse à Toulouse.

    C'est à proximité des ponts jumeaux et des minimes, et donc accessible par bus ou métro même tard le soir (bus 16 ou métro B en marchant un peu). Il n'y a pas de formule prévue, c'est à la carte pizzas, viandes, poissons, salades…

    Pour des raisons de logistique, une inscription préalable avant la veille est souhaitée sur toulibre.org/qjelt.

    [CA-QC Montréal] SQiL - Introduction au graphisme libre - Le jeudi 20 septembre 2018 de 19h00 à 21h30.

    Dans le cadre de la Semaine québécoise de l’informatique libre (SQIL), la SOGÉÉCOM vous invite à un atelier sur l'utilisation de logiciels libres de graphisme.

    Cette activité de formation est ouverte à tous et à toutes. Les personnes à qui elle s'adresse sont celles qui n'ont jamais utilisé d'outils de graphisme. Les individus plus expérimentés sont toutefois également la bienvenu.

    Le but de la formation est d'abord et avant tout présenter l'utilisation de base des logiciels libres de graphisme GIMP, Scribus et Inkscape. L'accent sera mis sur la production de matériel d'information, comme des affiches et des tracts.

    Des ordinateurs sont disponibles sur place. Vous pouvez toutefois apporter vos ordinateurs portables.

    Plan de la formation

    1. Introduction

      1. Pourquoi utiliser des logiciels libres
      2. Bonne pratiques de sauvegarde
      3. Installer GIMP, Scribus et Inkscape
    2. Introduction à GIMP

      1. Créer un document
      2. Les outils
      3. Les calques
      4. Les filtres
      5. Activité pratique faire une affiche
    3. Introduction à Scribus

      1. Créer un document
      2. Les repères
      3. Les boites de texte et d'image
      4. Activité pratique faire un tract
    4. Inkscape

      1. Les images vectorielles
      2. Les formes
      3. Activité pratique utiliser une photo pour créer une forme simplifiée

    Local B-1166.

    [CA-QC Coteau du Lac] Émission #160 de bloguelinux - Le jeudi 20 septembre 2018 de 20h00 à 21h00.

    bloguelinux.ca est un blogue québécois offrant la diffusion d'un podcast qui traite des logiciels libres, du système d'exploitation Linux et de la technologie en général il y a un processeur, il y a un système d'exploitation, c'est certain que ça nous intéresse

    bloguelinux.ca est enregistré le jeudi à 20h00 toutes les deux semaines.

    Vous pouvez nous écouter en direct lors des enregistrements à l'adresse http://live.bloguelinux.ca ou directement sur notre site à http://www.bloguelinux.ca en cliquant sur la radio dans le panneau de gauche du site.

    Vous pouvez rejoindre nos conversations avec Telegram en vous abonnant au groupe BlogueLinux en suivant le lien suivant https://t.me/joinchat/ArPfnFAOS1OB0u7pwZFQHA et dans notre salle de chat en vous connectant sur les serveurs de freenode.net dans la salle #bloguelinux.

    Si vous n'avez pas de client IRC, vous pouvez utiliser l'adresse http://webchat.freenode.net

    AVERTISSEMENT Ce podcast peut contenir du langage inapproprié ou vulgaire et peut ne pas convenir à tout le monde.

    Animateurs Patrick et Sandrine

    [FR Montpellier] Les logiciels libres, parlons-en - Le vendredi 21 septembre 2018 de 17h00 à 19h00.

    Les logiciels libres parlons-en Ouvrons le dialogue sur l’ouverture des données Partageons nos expériences pour une meilleure répartition des connaissances.

    Cette permanence vous permet de rencontrer le groupe Montpel’libre, ses activités, d’être orienté vers nos ateliers et permanences techniques et d’être accompagné pour une transition digitale progressive et adaptée vers les logiciels libres.

     Proposition de programme

    • discussions autour de l’organisation d’événements
    • gestion des groupes de travail
    • propositions diverses
    • présentation de l’asso

    Montpel’libre est un Groupe d’Utilisateurs GNU/Linux et Logiciels Libres qui promeut les logiciels libres, la culture libre et les biens communs.
    Notre association se situe à la jonction des secteurs d’activités du numérique, des industries culturelles et créatives, de l’économie sociale et solidaire, du développement durable, de la recherche et formation ainsi que de l’éducation populaire et de l’éducation scientifique.
    Elle s’adresse à l’informaticien comme au néophyte, au particulier comme au professionnel ou à l’étudiant et à un public de tout âge.

    Montpel’libre exerce des activités multiples autour de six pôles

    1. PERMANENCES
    2. ATELIERS
    3. CONFÉRENCES / FORMATIONS / EXPERTISE
    4. ÉVÉNEMENTIEL
    5. TECHNIQUE / SÉCURITÉ
    6. PUBLICATION

    Et de plusieurs communautés et groupes de travail.

    Ces permanences sont suivies d’un Apéro refaire le monde convivial et partagé, de 18h30 à 21h30. Elles ont lieu au Faubourg marché, tous les vendredis de 17h00 à 19h00.

    Entrée libre et gratuite sur inscription. Une simple adhésion à l’association est possible.

    Cet événement vous est proposé dans le cadre du partenariat qui lie Le Faubourg Marché et Montpel’libre.

    [FR Aix-en-Provence] L.A.B - Le vendredi 21 septembre 2018 de 19h00 à 23h00.

    [FR Orléans] Réunion mensuelle - Le vendredi 21 septembre 2018 de 20h30 à 23h00.

    La prochaine réunion de l'association aura lieu le vendredi 18 mai à partir de 20h30 à la salle des 

    (2 rue Edouard Branly à Orléans-la-Source)

    Au programme de ce vendredi

    • Les commandes Linux de base
    • Personnaliser son environnement de bureau

    Pour venir nous voir Plan d'accés

    Venez nombreux et parlez-en autour de vous car les réunions de l'association sont aussi ouvertes aux non adhérents.

    [CA-QC Montréal] SQiL - Maison des utilisateurs de logiciels libres de Montréal - Le vendredi 21 septembre 2018 de 13h30 à 19h00.

    C’est une maison à la fois physique au travers tous les endroits ou 3L-Logiciels libres en Liberté se déplace pour aller aider les utilisateurs de logiciels libres de tous niveaux, mais surtout pour les DÉBUTANTS. Et aussi virtuelle avec de l’aide à distance soit par téléphone (5149985644) ou par l’utilisation de logiciel d’aide à distance. Pour aider ceux qui sont dans le besoin et qui sont trop loin de Montréal pour avoir une aide direct en personne.

    Et le vendredi le 21 septembre 2018 de 13:30 à 19:00 pour une seconde chance de voir nos présentations uniques à Montréal car nous y sommes l’unique groupe d’utilisateurs (GULL) dans la grande région de Montréal.

    Rencontres pour tous les niveaux d’utilisateurs mais surtout pour les débutants par la présentation de systèmes d’exploitation libres de niveau débutant comme Elementary OS 4.1 Loki ou DFLinux (debian facile linux) strech 9.5.

    [FR Beauvais] Samedi du Libre sur Wordpress (site internet) - Le samedi 22 septembre 2018 de 09h30 à 12h00.

    Formation et partage de connaissances sur les points suivants* Installation
    * Paramètres de base
    * Organisation des menus et des articles
    * Pages statiques
    * Modules complémentaires interconnexion avec les réseaux sociaux, agenda, e-mailing

    [FR Rennes] Permanence Gulliver - Le samedi 22 septembre 2018 de 14h00 à 18h00.

    Venez installer GNU Linux ou un logiciel libre.

    [FR Boé] Arobase Café - Le samedi 22 septembre 2018 de 14h00 à 17h00.

    Les bénévoles de l'association aGeNUx sont invités à la médiathèque de Boé pour partager sur les différentes méthodes de sauvegardes de ses données.

    Venez nombreux.

    [FR Villeurbanne] Apprendre à construire et programmer un robot - Le samedi 22 septembre 2018 de 14h00 à 17h00.

    À partir de cette rentrée le Laboratoire Ouvert Villeurbannais démarre une série d’ateliers à destination des jeunes et adolescents.

    Le premier atelier se concentre sur tous les aspects de la construction d’un robot autonome basique.

    Lors de cet atelier les participants apprendront

    • les bases d’utilisation d’une carte électronique programmable Arduino
    • piloter des moteurs
    • lire des informations à partir de capteurs
    • fabriquer un châssis simple
    • mettre ensemble toutes les notions pour faire un robot autonome

    Informations pratiques voir le lien pour les modalités pratiques et l'inscription

    [FR Ivry sur Seine] Cours de l'Ecole du Logiciel Libre - Le samedi 22 septembre 2018 de 14h30 à 18h30.

    Présentation de l'E2L

    Quel est le rôle de l'école du logiciel libre

    Tout d'abord, ce n'est pas une école comme les autres. Elle n'a pas d'établissement fixe, pas de cours de récréation, pas de carte d'étudiant, ni de diplôme de fin d'année.

    Comme toutes les écoles, son rôle est d'apprendre à ses élèves les logiciels libres, c'est-à-dire

    • comment en trouver de bons parmi les nombreux sites qui en proposent,
    • comment en prendre possession en fonction des licences,
    • comment les installer en fonction de ses besoins,
    • comment les tester et les utiliser,
    • comment en comprendre le fonctionnement pour ensuite les modifier,
    • comment écrire ses propres logiciels libres.

    En fait, l'école du logiciel libre est une université populaire, comme celles qui ont vu le jour en France à partir du 19 ème siècle, et dont le but est de transmettre des connaissances théoriques ou pratiques à tous ceux qui le souhaitent. Et pour atteindre ce but, sa forme juridique est de type " association à but non lucratif ".

    Comment fonctionne l'école

    Cette école étant une association, elle possède, comme toutes les autres, un bureau, élu chaque année en assemblée générale, pour l'administrer. Mais elle a aussi des responsables pédagogiques dont le rôle est essentiel car ce sont eux qui établissent les programmes des cours en fonction des souhaits des adhérents, valident les candidatures des enseignants et affectent les sessions.

    Les membres du bureau et les responsables pédagogiques forment "l'encadrement de l'école ". Tous les membres "encadrants" doivent être membres de l'association.

    Les locaux où se déroulent les cours seront ceux que l'on veut bien nous prêter une salle des fêtes, un théâtre, une salle de réunion publique, un amphi dans une école publique, ou autre.

    Les thèmes des cours sont définis par les adhérents en fonction de leurs envies, de leurs besoins. Les cours sont ensuite décidés par les responsables pédagogiques de l'école en fonction des enseignants disponibles.

    Afin de permettre au plus grand nombre de participer et d'assister aux cours, les sessions se tiennent essentiellement le samedi. Une première de 9h à 12h30, et une autre de 14h à 17h30.

    Programme détaillé sur le site http://e2li.org

    [FR Vandœuvre-lès-Nancy] Découvrir un poste informatique - Le samedi 22 septembre 2018 de 15h00 à 17h00.

    Cet atelier vous apprendra les rudiments du clavier et de la souris, à faire connaissance avec les bases de l’interface graphique, et à faire vos premiers pas dans un gestionnaire de fichiers.

    Inscription gratuite aux ateliers

    La participation aux animations repose sur un système d’inscriptions préalables qui permet de répondre de façon plus ciblée aux attentes des usagers et de les associer au projet.

    L'inscription est obligatoire au plus tard 30 min avant l’atelier.

    [CA-QC Montréal] SQiL - Intro à la création d'extensions de navigateur en JavaScript - Le samedi 22 septembre 2018 de 09h30 à 16h30.

    Femmes en programmation Introduction à la création d'extensions de navigateur en JavaScript - Montréal (En Français)

    Durant cette expérience, nous apprendrons les rudiments du JavaScript en mettant l'accent sur les variables et les boucles. Ce langage de programmation nous permettra d'interagir avec le web et d'accomplir des tâches comme remplacer ou modifier du contenu sur des pages web. De plus, nous aborderons des questions d'éthique liées aux autorisations des extensions et sensibiliserons les apprenantes à la protection de la vie privée en ligne. Les participantes utiliseront des outils de développement pour découvrir des aspects comme la manipulation DOM et créer leur propre extension de navigateur personnalisée. Finalement, les apprenantes auront à leur disposition une liste de ressources pour modifier l'extension, la rendre compatible avec d'autres navigateurs et la partager avec d'autres utilisateurs.

    Cet atelier est axé sur la pratique. Les participantes

    apprendront des techniques et des concepts de programmation de base transférables vers d'autres langages de programmation

    verront les blocs de construction de base du HTML, du CSS et du JavaScript et apprendront comment ceux-ci travaillent ensemble pour améliorer notre expérience en ligne

    chargeront et mettront à jour leurs extensions avec le mode développeur de Chrome

    modifieront et remplaceront les éléments avec du JavaScript (plus de chatons sur le web)

    auront une idée des ressources disponibles en ligne pour continuer à apprendre

    Quel est le public cible

    Conçus pour les adultes s’identifiant comme femme ou homme, transgenres ou non binaires, nos ateliers Ladies Learning Code offrent des activités d’apprentissage par projets axées sur la pratique donnant aux débutants les compétences et la confiance nécessaires pour devenir des créateurs avec la technologie.

    Prérequis aucun, vous n'avez qu'à apporter votre laptop

    [BE Saint Gilles] Gnu/Linux Install party - Le dimanche 23 septembre 2018 de 10h00 à 18h00.

    L’une des grandes qualités des logiciels libres, c’est qu’on peut librement les copier, les installer, les tester

    Une Linux Install Party est une réunion où tout un chacun peut

    • venir copier, échanger, se faire assister dans l'installation de logiciels libres
    • partager des connaissances, des configurations, faire circuler des informations…
    • faire connaissance avec une culture du Libre.

    Chaque quatrième dimanche du mois, nous organisons une Install Party à l’atelier multimedia de l’asbl fij

    Le comité asbl BxLUG 2018

    [FR Ramonville-Saint-Agne] Village des alternatives - Le dimanche 23 septembre 2018 de 10h00 à 18h00.

    Le club CULTe (Club des utilisateurs de Logiciels libres et de gnu/linux de Toulouse et des environs" sera présent lors du "Village des alternatives" (alternatiba.eu/toulouse) pour faire connaître l'alternative que représente l'informatique "libre".

    Sa présence est d'autant plus naturelle que cette association exerce ses activités à Ramonville Saint Agne depuis plus de 20 ans.

    Commentaires : voir le flux atom ouvrir dans le navigateur