Linuxfr

Syndiquer le contenu
Mis à jour : il y a 7 min 8 sec

Le Capitole du Libre, jusqu'au dimanche 21 septembre pour proposer votre participation !

il y a 15 heures 3 min

Vous le savez sûrement, le Capitole du Libre 2014 aura lieu les samedi 15 et dimanche 16 novembre prochains.

Le Capitole du Libre est l'événement du Libre à Toulouse ; il accueille cette année notamment Adrienne Charmet de La Quadrature du Net, Lionel Maurel juriste et bibliothécaire, et Benjamin Bayart de FFDN. Il y aura également Pierre Ficheux d'Open Wide, auteur du livre Linux Embarqué et Christophe Blaess, ingénieur indépendant qui aide régulièrement à la conception de systèmes Linux embarqués ou nécessitant des contraintes temps réel fortes.

Des conférences et ateliers sont proposés au travers de diverses thématiques telles que les enjeux du Libre, le Multimédia, Internet Libre, la Bureautique, l'Embarqué et DevOps.

Le Capitole du Libre accueille également deux événements hébergés :

  • la communauté LibreOffice pour un Hackfest ;
  • la communauté KDE au travers d'Akademy-FR.

Il ne reste que quelques jours pour proposer une conférence ou un atelier à cet événement. Alors n'hésitez pas.

Thématiques de conférences et ateliers

Cette année les thèmes abordés seront :

  • Grand Public et Enjeux du Libre (découverte, éducation, juridique, biens communs…) ;
  • Technique (système, développement, réseau…) ;
  • Multimédia & Bureautique (graphisme, vidéo, son, ainsi que les logiciels de bureau) ;
  • Internet Libre (outils libre pour l'auto-hébergement de site, de mail…) ;
  • Open Hardware et Embarqué (Arduino, Raspberry Pi…) ;
  • DevOps (déploiement et intégration automatisée).

Les propositions sont encore ouvertes jusqu'au 21 septembre à minuit. Nous remercions celles et ceux qui ont déjà proposé leur participation, ils seront notifiés de notre décision la semaine du 22 septembre au plus tard.

Événements hébergés LibreOffice Hackfest

Dans un Hackfest, les contributeurs se réunissent afin de coordonner dans un temps donné et dans une atmosphère détendue, le développement du produit et faire avancer le projet.

Akademy-FR

Événement français de la communauté KDE, l'objectif est de permettre aux contributeurs francophones de se retrouver, mais également de promouvoir les produits de la communauté à l'échelle française.

Pour les novices, c'est l'occasion rêvée de découvrir cet environnement libre et complet. Pour les personnes souhaitant contribuer, elles pourront rencontrer des contributeurs d'horizons divers qui les aideront à se lancer dans le grand bain KDE. Vous retrouverez donc à la fois des conférences orientées contribution mais également grand public.

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Atelier framebuffer à Bordeaux le 29 septembre 2014

ven, 19/09/2014 - 14:40

Le lundi 29 septembre 2014 se tiendra le deuxième atelier CLI dont le thème porte sur le framebuffer.

Le but de ces ateliers, proposés par des membres d’associations et collectifs Bordelais, est de progresser ensemble autour d'un outil ou d'un thème, toujours en ligne de commande. Les ateliers de type spécial débutants reprendront le 13 octobre.

Cet atelier se déroulera dans les locaux du L@BX, à la fabrique POLA (Rue Marc Sangnier, 33130 Bègles).

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Cartopartie OpenStreetMap pour la Fête du Parc du Verdon - dimanche 28 septembre 2014 à La Verdière

ven, 19/09/2014 - 10:26

APITUX vous emmène à la découverte de la cartographie libre OpenStreetMap. Venez dessiner avec nous le plan de La Verdière, ses rues et ses chemins, ses places et ses fontaines, ses points d'intérêt et ses services. Un atelier proposé dans le cadre de la Fête du Parc du Verdon, dimanche 28 septembre 2014 de 14h à 17h. Inscription gratuite au 04 92 74 68 00.

OpenStreetMap est une base de données géographique construite de manière collaborative et publiée sous licence libre. Le projet reprend les principes qui ont fait le succès de Wikipédia. La contribution est ouverte à tous, chacun peut cartographier sa commune, son quartier, sa randonnée préférée. La carte du monde se dessine progressivement par l'assemblage de toutes les contributions.

Le Parc naturel régional du Verdon est un territoire de projets qui regroupe 46 communes des Alpes-de-Haute-Provence et du Var. Il compte plus de 30 000 habitants pour une surface de 180 000 hectares. Les missions, les objectifs, l'organisation du Parc font l'objet d'une charte qui fédère les collectivités adhérentes et l'État autour d'un projet concerté de développement durable conclu pour une période de 12 ans.

APITUX est spécialisé dans la formation et le conseil en informatique libre. Il intervient en tant qu'expert auprès des collectivités sur les logiciels libres adaptés à leurs métiers, la mise en place et l'animation de leurs démarches opendata et la cartographie collaborative avec OpenStreetMap.

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Aperi’tic logiciel libre en milieu professionnel - jeudi 25 septembre 2014 à Gap

ven, 19/09/2014 - 10:12

Un Aperi’tic consacré au logiciel libre en milieu professionnel, jeudi 25 septembre 2014 de 10h à 12h à la CCI 05, 16 rue Carnot à Gap.

Né au MIT en 1983, le logiciel libre est aujourd'hui sorti des laboratoires de recherche pour s'établir très largement dans tous les domaines de l'informatique. On trouve des logiciels libres dans les « Box » qui gèrent nos connexions Internet, sur nos ordinateurs personnels et nos postes de travail mais aussi dans nos téléphones et autres objets technologiques qui peuplent notre quotidien. L'histoire du logiciel libre est intimement liée à celle du réseau Internet. Saviez-vous que la majorité des serveurs web fonctionnent avec des logiciels libres ?

Comment fonctionnent les licences de ces logiciels que chacun peut utiliser, copier, étudier et modifier librement en toute légalité ? Quels sont les modèles économiques du logiciel libre ? Quels sont les enjeux dans le cadre d'une utilisation professionnelle ?

D'un point de vue pratique, quels sont les logiciels libres utilisables ? Pour la bureautique ? Pour l'internet et le multimédia ? Pour le travail collaboratif et le partage de données en réseau ? Quel est l'état de l'art en matière de logiciels libres pour la gestion d'entreprise ? Comment s'y prendre pour tirer le meilleur parti de ces solutions ? Telles sont les questions auxquelles répondra Jean-Christophe Becquet, directeur d'APITUX et vice-président de l'April, expert du logiciel libre en milieu professionnel depuis 1997.

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Formation, Certification et Technologie Libre

ven, 19/09/2014 - 08:52

L'Institut de Technologie Libre (ITL) organise sur Perpignan et (bientôt) sur Montpellier une formation menant au Titre Professionnel Concepteur(trice) Développeur(se) Informatique de niveau 2 délivré par le Ministère du Travail, de l'Emploi, de la Formation Professionnelle et du Dialogue social.

L'ITL est agréé par la Direction Régionale des Entreprises, de la concurrence, de la Consommation du Travail et de l'Emploi (Languedoc-Roussillon), pour organiser des sessions de validation pour ce Titre Professionnel.

Dans le cadre de cette formation, l'ITL utilise exclusivement des logiciels libres (e.g. PostgreSQL) et des standards ouverts (e.g. HTML5).

Le programme de formation couvre les trois Certificats de Compétences Professionnelles composant le Titre Professionnel :

  • développer des composants d'interface ;
  • développer la persistance des données ;
  • développer une application n-tiers.

La prochaine session de formation démarre le 21/01/2015 et finit le 19/07/2015, tandis que celle de validation démarre le 27/07/2015 pour une durée de cinq jours.

Comme l'ITL accueille des candidats non informaticiens (en reconversion professionnelle), une préparation (facultative) est organisée. La prochaine session de préparation démarre le 21/10/2014 et finit le 20/01/2015.

L'ITL organise également une session de validation blanche (facultative), laquelle démarre le 20/07/2015 et dure cinq jours. De plus amples informations, un formulaire de demande d'information et un formulaire de candidature figurent sur le site de l'ITL.

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Sortie de Odoo 8 (anciennement OpenERP)

jeu, 18/09/2014 - 21:11

Odoo, la suite libre d'applications de gestion, vient de sortir sa version 8. Dans les nouvelles fonctionnalités, on retrouve un point de vente fonctionnant aussi sur iPad et Android, un outil de création de site internet, une boutique en ligne, un moteur de rapports statistiques, un système de blogue (clone open source de Medium).

Quelques applications marketing ont également été publiées : envois de mails, une gestion d'événements, un outil de création de sondages et un clone de Stackoverflow (Q&A)

Le cadriciel Python a été totalement réécrit permettant d'être plus efficace pour créer des modules personnalisés.

Toutes les applications de gestion d'Odoo ont été complétées d'une interface frontend (site web). Quelques exemples de fonctionnalités qui sont apparues grâce à la partie web :

  • ventes : une boutique en ligne ;
  • événement : un site web de publication d'événements et vente de tickets ;
  • recrutements : publication des offres d'emploi et formulaires pour postuler ;
  • devis : version en ligne des devis construite sur base de modèles ;
  • composition graphique d'e-mails pour l'envoi massif ;
  • gestion de la relation client : formulaires de contact.

Cette version est le résultat de 18 mois de recherche et développement avec une collaboration efficace entre l'éditeur et la communauté. Une bonne partie des modules communautaires ont d'ailleurs déjà été portés à la nouvelle API.

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Numba 0.14

jeu, 18/09/2014 - 06:47

Numba, l'optimiseur Python spécialisé dans le calcul numérique, est sorti en version 0.14. Numba est un compilateur juste-à-temps (JIT) pour Python, basé sur LLVM, permettant d'optimiser du code de calcul numérique, notamment basé sur Numpy. Il est compatible avec CPython 2.6, 2.7, 3.3 et 3.4. Des paquets binaires sont disponibles via Anaconda, la distribution de paquets binaires dédiée au calcul scientifique maintenue par Continuum Analytics, l'entreprise qui développe Numba.

Sommaire Qu'est-ce que Numba ?

Numba est un compilateur juste à temps pour CPython spécialisé dans l'optimisation de code scientifique.

… CPython ?

CPython est l'implémentation par défaut (ou "de référence", en langage politiquement correct) de Python. Les autres implémentations s'appellent PyPy, Jython, etc.

… Spécialisé ?

Numba ne prétend pas être capable d'optimiser tous les types de code Python, ni même toutes les constructions du langage (même si cela n'est pas exclu comme objectif à long terme). Numba est capable d'optimiser les calculs numériques et scientifiques impliquant des entiers, des flottants, des complexes ; il est capable de reconnaître certaines types de données bien connus, comme les tableaux Numpy.

La liste des fonctionnalités optimisables grandit évidemment de version en version, par exemple la version 0.14 supporte désormais les types numpy.datetime64 et numpy.timedelta64, qui permettent de faire des calculs sur des séries temporelles.

… Juste à temps ?

Numba fonctionne lors de l'exécution de votre code Python. Il suffit d'apposer le décorateur "@numba.jit" à une fonction pour la faire optimiser par Numba (certains aiment prier pour qu'il arrive à l'optimiser). Il n'y a pas de phase de compilation séparée, ni de ligne de commande à lancer.

Plateformes supportées

Numba utilise LLVM, ce qui permet une portabilité relativement aisée. Actuellement, les systèmes sous Linux, OS X et Windows sont supportés. Côté matériel, x86, x86-64 sont supportés et il y a également un backend CUDA (avec des limitations).

Un exemple

Partons de notre ami l'ensemble de Mandelbrot. Pour cela, posons la fonction suivante dans un fichier nommé mandel.py :

import numpy def mandelbrot(width, height): x_min, x_max = -2.0, 1.0 y_min, y_max = -1.0, 1.0 arr = numpy.zeros((height, width), dtype=int) xs = numpy.linspace(x_min, x_max, num=width) ys = numpy.linspace(y_min, y_max, num=height) max_iters = 20 for idx_x, x in enumerate(xs): for idx_y, y in enumerate(ys): c = complex(x, y) z = 0.0j for i in range(max_iters): z = z * z + c if z.real * z.real + z.imag * z.imag >= 4: # Hors de l'ensemble break else: # Dans l'ensemble arr[idx_y, idx_x] = 1 return arr

Cette fonction renvoie un tableau d'entiers Numpy indiquant si un point fait partie de l'ensemble de Mandelbrot (1) ou non (0).

Maintenant, lançons un Python depuis le même répertoire :

>>> import mandel >>> print(mandel.mandelbrot(20, 15)) [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0] [0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]

Ouf, ça ressemble :-) Maintenant compilons cette même fonction avec Numba :

>>> from numba import jit >>> opt = jit(mandel.mandelbrot) >>> print(opt(20, 15)) [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0] [0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]

Et lançons un benchmark d'une scientificité rigoureuse sur un tableau de 200x200 :

>>> import timeit >>> timeit.timeit("mandel.mandelbrot(200, 200)", setup="import mandel", number=1) 0.20483311700081686 >>> timeit.timeit("opt(200, 200)", setup="from __main__ import opt", number=1) 0.003343598000355996

Sur ce cas d'usage d'une grande importance, Numba est ainsi 60 fois plus rapide que l'interpréteur CPython !

Principe de fonctionnement

Numba est un optimiseur fonction par fonction. Il part de la fonction que vous décorez avec numba.jit et lance une inférence de types pour essayer d'assigner un type précis à chaque variable et valeur intermédiaire dans la fonction. Pour cela, il utilise des règles dédiées à chaque opérateur, fonction standard, etc.

Pour définir les types de départ du processus d'inférence, il y a en réalité deux possibilités :

  • Dans l'utilisation de base de numba.jit, l'utilisateur ne passe pas de paramètres : c'est alors lors de l'appel de la fonction décorée que les types des arguments sont utilisés pour lancer le processus d'inférence (la compilation est ici paresseuse).
  • Dans une utilisation avancée, l'utilisateur peut décrire explicitement les types à l'entrée de la fonction (cela lui permet, par exemple, de choisir des flottants simple précision plutôt que double précision) ; dans ce cas, la compilation a lieu immédiatement.

L'inférence de type est l'étage fondamental qui permet ensuite de produire du code travaillant sur des types bas niveau, plutôt qu'au niveau du modèle objet de Python, qui est beaucoup plus difficile à optimiser. Bien entendu, la chaîne de traitement (pipeline) est constituée de multiples étages :

  1. décodage du bytecode CPython
  2. construction d'un graphe de flot de contrôle (CFG)
  3. génération d'une représentation intermédiaire (IR) spécifique à Numba
  4. inférence de types, produisant une détermination du type de chaque variable manipulée par la fonction
  5. génération de code LLVM correspondant à l'exécution de l'IR sur les types déterminés précédemment
  6. appel à LLVM pour la génération du code machine, et encapsulation du tout dans un objet dédié (wrapper) qui lance le code machine quand il est appelé

Grâce à LLVM, Numba n'a pas à se charger des optimisations bas niveau (propagation de constantes, vectorisation SIMD, etc.) et peut se concentrer sur les traitements spécifiques au langage Python.

Pour une présentation plus détaillée, il convient de lire la documentation (en anglais) : architecture de Numba.

Limitations

À l'heure actuelle, plutôt que de se lancer dans une liste interminable de limitations, il est plus raisonnable de lister ce qui est supporté.

Types supportés
  • les scalaires numériques, que ce soit les types Python (int, float, complex…) ou NumPy (numpy.complex64, etc.)
  • les booléens
  • les dates et intervalles de temps NumPy (numpy.datetime64 et numpy.timedelta64)—mais pas les types standard datetime.datetime et datetime.timedelta
  • les tuples des types ci-dessus
  • les tableaux NumPy des types ci-dessus
Constructions supportées

Numba supporte la plupart des constructions syntaxiques du langage, sauf le traitement des exceptions (try... except, etc.), les gestionnaires de contexte (with), les générateurs (yield) et quelques autres détails.

Fonctions supportées

Numba supporte une grande partie des opérateurs numériques, des fonctions standard (notamment le module math), et certaines fonctions de NumPy. Il est également capable d'optimiser les appels à des fonctions externes via ctypes ou cffi.

Différences sémantiques

Le caractère volontaire (opt-in) de la compilation permet à Numba de présenter des différences sémantiques par rapport au langage Python. Je ne les listerai pas ici, mais une différence évidente a trait aux entiers : les entiers de Python sont de largeur arbitraire, ceux de Numba sont de largeur fixe (déterminée à l'inférence de types, ou forcée par l'utilisateur). Un dépassement lors d'opérations mathématiques entraîne simplement une troncation.

Notons qu'une grande partie de ces différences reflète en réalité le comportement de NumPy (dont les entiers sont aussi à largeur fixe, par exemple).

Numba et l'écosystème Python

Le fait que Numba fonctionne au-dessus de CPython lui permet de s'intégrer facilement à l'écosystème existant. Comme on l'aura compris, l'intégration avec NumPy est également une fonctionnalité de premier plan. D'une manière générale, la stratégie de Continuum (cf. ci-dessous) est de maximiser les possibilités d'interaction entre les multiples briques de calcul scientifique disponibles pour Python.

Statut du projet

Numba est supporté par Continuum Analytics, qui paye à cet effet plusieurs développeurs (dont l'auteur de cette dépêche). Le développement est en partie financé par des clients et des fonds de recherche américains. Nous recevons également des contributions extérieures. Bien entendu, le projet est libre (licence de type MIT).

Contribuer

Numba est un projet jeune auquel manquent de nombreuses fonctionnalités ; il y a donc beaucoup d'opportunités de contribution. Le processus est détaillé dans la documentation. Les compétences nécessaires dépendent de ce à quoi vous vous intéressez :-) La majeure partie du code de Numba est en Python ; il y a quelques parties en C, mais on les évite assez facilement. Nul besoin d'être en expert en NumPy ou en LLVM pour commencer (je ne les connaissais presque pas).

Au débotté, voici quelques directions possibles de contribution, par ordre de difficulté :

  • améliorer la documentation
  • améliorer le retour utilisateur, qui est actuellement assez fruste (messages d'erreur, informations sur la fonction compilée)
  • corriger des bugs (!)
  • ajouter le support de nouvelles fonctions (de la bibliothèque standard ou de NumPy)
  • ajouter le support de nouveaux types
  • ajouter le support de nouvelles constructions (comme la gestion des exceptions ou les générateurs)
Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Numba 1.4

jeu, 18/09/2014 - 06:47

Numba, l'optimiseur Python spécialisé dans le calcul numérique, est sorti en version 1.4. Numba est un compilateur juste-à-temps (JIT) pour Python, basé sur LLVM, permettant d'optimiser du code de calcul numérique, notamment basé sur Numpy. Il est compatible avec CPython 2.6, 2.7, 3.3 et 3.4. Des paquets binaires sont disponibles via Anaconda, la distribution de paquets binaires dédiée au calcul scientifique maintenue par Continuum Analytics, l'entreprise qui développe Numba.

Sommaire Qu'est-ce que Numba ?

Numba est un compilateur juste à temps pour CPython spécialisé dans l'optimisation de code scientifique.

… CPython ?

CPython est l'implémentation par défaut (ou "de référence", en langage politiquement correct) de Python. Les autres implémentations s'appellent PyPy, Jython, etc.

… Spécialisé ?

Numba ne prétend pas être capable d'optimiser tous les types de code Python, ni même toutes les constructions du langage (même si cela n'est pas exclu comme objectif à long terme). Numba est capable d'optimiser les calculs numériques et scientifiques impliquant des entiers, des flottants, des complexes ; il est capable de reconnaître certaines types de données bien connus, comme les tableaux Numpy.

La liste des fonctionnalités optimisables grandit évidemment de version en version, par exemple la version 0.14 supporte désormais les types numpy.datetime64 et numpy.timedelta64, qui permettent de faire des calculs sur des séries temporelles.

… Juste à temps ?

Numba fonctionne lors de l'exécution de votre code Python. Il suffit d'apposer le décorateur "@numba.jit" à une fonction pour la faire optimiser par Numba (certains aiment prier pour qu'il arrive à l'optimiser). Il n'y a pas de phase de compilation séparée, ni de ligne de commande à lancer.

Plateformes supportées

Numba utilise LLVM, ce qui permet une portabilité relativement aisée. Actuellement, les systèmes sous Linux, OS X et Windows sont supportés. Côté matériel, x86, x86-64 sont supportés et il y a également un backend CUDA (avec des limitations).

Un exemple

Partons de notre ami l'ensemble de Mandelbrot. Pour cela, posons la fonction suivante dans un fichier nommé mandel.py :

import numpy def mandelbrot(width, height): x_min, x_max = -2.0, 1.0 y_min, y_max = -1.0, 1.0 arr = numpy.zeros((height, width), dtype=int) xs = numpy.linspace(x_min, x_max, num=width) ys = numpy.linspace(y_min, y_max, num=height) max_iters = 20 for idx_x, x in enumerate(xs): for idx_y, y in enumerate(ys): c = complex(x, y) z = 0.0j for i in range(max_iters): z = z * z + c if z.real * z.real + z.imag * z.imag >= 4: # Hors de l'ensemble break else: # Dans l'ensemble arr[idx_y, idx_x] = 1 return arr

Cette fonction renvoie un tableau d'entiers Numpy indiquant si un point fait partie de l'ensemble de Mandelbrot (1) ou non (0).

Maintenant, lançons un Python depuis le même répertoire :

>>> import mandel >>> print(mandel.mandelbrot(20, 15)) [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0] [0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]

Ouf, ça ressemble :-) Maintenant compilons cette même fonction avec Numba :

>>> from numba import jit >>> opt = jit(mandel.mandelbrot) >>> print(opt(20, 15)) [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0] [0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0] [0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]

Et lançons un benchmark d'une scientificité rigoureuse sur un tableau de 200x200 :

>>> import timeit >>> timeit.timeit("mandel.mandelbrot(200, 200)", setup="import mandel", number=1) 0.20483311700081686 >>> timeit.timeit("opt(200, 200)", setup="from __main__ import opt", number=1) 0.003343598000355996

Sur ce cas d'usage d'une grande importance, Numba est ainsi 60 fois plus rapide que l'interpréteur CPython !

Principe de fonctionnement

Numba est un optimiseur fonction par fonction. Il part de la fonction que vous décorez avec numba.jit et lance une inférence de types pour essayer d'assigner un type précis à chaque variable et valeur intermédiaire dans la fonction. Pour cela, il utilise des règles dédiées à chaque opérateur, fonction standard, etc.

Pour définir les types de départ du processus d'inférence, il y a en réalité deux possibilités :

  • Dans l'utilisation de base de numba.jit, l'utilisateur ne passe pas de paramètres : c'est alors lors de l'appel de la fonction décorée que les types des arguments sont utilisés pour lancer le processus d'inférence (la compilation est ici paresseuse).
  • Dans une utilisation avancée, l'utilisateur peut décrire explicitement les types à l'entrée de la fonction (cela lui permet, par exemple, de choisir des flottants simple précision plutôt que double précision) ; dans ce cas, la compilation a lieu immédiatement.

L'inférence de type est l'étage fondamental qui permet ensuite de produire du code travaillant sur des types bas niveau, plutôt qu'au niveau du modèle objet de Python, qui est beaucoup plus difficile à optimiser. Bien entendu, la chaîne de traitement (pipeline) est constituée de multiples étages :

  1. décodage du bytecode CPython
  2. construction d'un graphe de flot de contrôle (CFG)
  3. génération d'une représentation intermédiaire (IR) spécifique à Numba
  4. inférence de types, produisant une détermination du type de chaque variable manipulée par la fonction
  5. génération de code LLVM correspondant à l'exécution de l'IR sur les types déterminés précédemment
  6. appel à LLVM pour la génération du code machine, et encapsulation du tout dans un objet dédié (wrapper) qui lance le code machine quand il est appelé

Grâce à LLVM, Numba n'a pas à se charger des optimisations bas niveau (propagation de constantes, vectorisation SIMD, etc.) et peut se concentrer sur les traitements spécifiques au langage Python.

Pour une présentation plus détaillée, il convient de lire la documentation (en anglais) : architecture de Numba.

Limitations

À l'heure actuelle, plutôt que de se lancer dans une liste interminable de limitations, il est plus raisonnable de lister ce qui est supporté.

Types supportés
  • les scalaires numériques, que ce soit les types Python (int, float, complex…) ou NumPy (numpy.complex64, etc.)
  • les booléens
  • les dates et intervalles de temps NumPy (numpy.datetime64 et numpy.timedelta64)—mais pas les types standard datetime.datetime et datetime.timedelta
  • les tuples des types ci-dessus
  • les tableaux NumPy des types ci-dessus
Constructions supportées

Numba supporte la plupart des constructions syntaxiques du langage, sauf le traitement des exceptions (try... except, etc.), les gestionnaires de contexte (with), les générateurs (yield) et quelques autres détails.

Fonctions supportées

Numba supporte une grande partie des opérateurs numériques, des fonctions standard (notamment le module math), et certaines fonctions de NumPy. Il est également capable d'optimiser les appels à des fonctions externes via ctypes ou cffi.

Différences sémantiques

Le caractère volontaire (opt-in) de la compilation permet à Numba de présenter des différences sémantiques par rapport au langage Python. Je ne les listerai pas ici, mais une différence évidente a trait aux entiers : les entiers de Python sont de largeur arbitraire, ceux de Numba sont de largeur fixe (déterminée à l'inférence de types, ou forcée par l'utilisateur). Un dépassement lors d'opérations mathématiques entraîne simplement une troncation.

Notons qu'une grande partie de ces différences reflète en réalité le comportement de NumPy (dont les entiers sont aussi à largeur fixe, par exemple).

Numba et l'écosystème Python

Le fait que Numba fonctionne au-dessus de CPython lui permet de s'intégrer facilement à l'écosystème existant. Comme on l'aura compris, l'intégration avec NumPy est également une fonctionnalité de premier plan. D'une manière générale, la stratégie de Continuum (cf. ci-dessous) est de maximiser les possibilités d'interaction entre les multiples briques de calcul scientifique disponibles pour Python.

Statut du projet

Numba est supporté par Continuum Analytics, qui paye à cet effet plusieurs développeurs (dont l'auteur de cette dépêche). Le développement est en partie financé par des clients et des fonds de recherche américains. Nous recevons également des contributions extérieures. Bien entendu, le projet est libre (licence de type MIT).

Contribuer

Numba est un projet jeune auquel manquent de nombreuses fonctionnalités ; il y a donc beaucoup d'opportunités de contribution. Le processus est détaillé dans la documentation. Les compétences nécessaires dépendent de ce à quoi vous vous intéressez :-) La majeure partie du code de Numba est en Python ; il y a quelques parties en C, mais on les évite assez facilement. Nul besoin d'être en expert en NumPy ou en LLVM pour commencer (je ne les connaissais presque pas).

Au débotté, voici quelques directions possibles de contribution, par ordre de difficulté :

  • améliorer la documentation
  • améliorer le retour utilisateur, qui est actuellement assez fruste (messages d'erreur, informations sur la fonction compilée)
  • corriger des bugs (!)
  • ajouter le support de nouvelles fonctions (de la bibliothèque standard ou de NumPy)
  • ajouter le support de nouveaux types
  • ajouter le support de nouvelles constructions (comme la gestion des exceptions ou les générateurs)
Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Apéro Python à Lyon le mercredi 24 septembre

mer, 17/09/2014 - 19:25

Un apéro Python aura lieu à Lyon le mercredi 24 septembre à partir de 19h à l'Antre Autre (11 rue Terme, Lyon 1er). Un AFPyro est un moment convivial où les Pythonistes peuvent échanger librement autour d’un verre ou d’une assiette.

Une présentation sur les docstrings sera proposée. Les docstrings permettent de rédiger la documentation développeur directement dans le code.

Venez nombreux !

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Install Party GNU/Linux le samedi 27 septembre à Marseille

mer, 17/09/2014 - 07:34

L'association CercLL (CercLL d'Entraide et Réseau Coopératif autour des Logiciels Libres) vous invite à une install party GNU/Linux, le samedi 27 septembre 2014 de 14h30 à 19h30 dans la salle de la Fabulerie au 4 rue de la bibliothèque 13001 Marseille. Au programme :

  • découverte de l'univers des logiciels libres ;
  • installation d'un environnement GNU/Linux, ainsi que le meilleur des logiciels libres ;
  • démonstration de jeux vidéo sous Linux.

L'entrée est libre, et l'évènement est accessible aux débutants-e-s. Une participation de 2 euros est demandée. Vous pourrez, si vous le souhaitez, adhérer à l'association pour la soutenir (cotisation de 20 euros pour une durée d'un an). Si vous avez d'autres questions en préalable à votre venue à l'évènement, une adresse mail de contact est disponible : cerll13@gmail.com.


Vous avez envie de découvrir un système d'exploitation libre, simple d'utilisation, stable, rapide et sécurisé ? Vous souhaitez une nouvelle façon d'utiliser votre ordinateur ? Vous vous sentez une affection naissante pour le gnou et le manchot, les mascottes de GNU/Linux ? Venez avec votre ordinateur ! Nous installerons ensemble une distribution GNU/Linux avec des logiciels libres et gratuits pour une utilisation quotidienne.

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

FACIL célèbre la Journée internationale du logiciel libre à Montréal le samedi le 20 septembre 2014

mar, 16/09/2014 - 22:02

FACIL, pour l'appropriation collective de l'informatique libre (FACIL) invite le grand public de la région de Montréal, de même que les acteurs et actrices de la communauté du libre à converger au Centre de recherche informatique de Montréal (CRIM), le samedi 20 septembre 2014, pour célébrer la Journée internationale du logiciel libre (JILL). Cet événement, qui inaugure la Semaine québécoise de l'informatique libre (SQIL) du 20 au 28 septembre, est gratuit et ouvert à tous et toutes, sans distinction d'âge.

Au programme cette année :

  1. En avant-midi, dévoilement du prototype de la Clé FACIL, dont la campagne de financement participatif sera lancée le jour même, ainsi que des présentations variées venant des membres de la communauté du libre.
  2. En après-midi, débutant à 14h, une table ronde sur les ressources éducatives libres (REL) au Québec, avec des expert(e)s du milieu de l'enseignement et de la recherche.
  3. 5@7 d'ouverture de la SQIL au Café l'Artère en compagnie des passionné(e)s du Club Linux Atomic.

QUAND : le samedi 20 septembre de 9 h à 17 h

OÙ : CRIM, 405, avenue Ogilvy à Montréal (métro Parc)

Pour plus d'infos. : http://jill.facil.qc.ca/http://cle.facil.qc.ca/http://2014.sqil.info/

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Parution du second tome du Guide d’autodéfense numérique

mar, 16/09/2014 - 20:01

Quatre ans après la parution du premier tome du Guide d'autodéfense numérique, le second tome, dédié aux enjeux liés de l'utilisation des réseaux et d'Internet est enfin terminé. Cet ouvrage vise à présenter l’« absence d’intimité » du monde numérique et propose des méthodes pour ajuster ses pratiques quotidiennes en conséquence. Les deux volumes sont d’ores et déjà disponibles en consultation et en version imprimable à l’adresse http://guide.boum.org/.

    Les technologies numériques, auxquelles il est devenu très difficile d’échapper, offrent des possibilités de contrôle et de surveillance inédites. S’ils semblent souvent très pratiques, ces outils sont également de puissants supports dans les processus de surveillance et de répression. C’est à partir de ce constat, et de la détermination à ne pas se laisser contrôler par quelque Big Brother que ce soit, qu’un collectif s’est attelé il y a plus de quatre ans à la rédaction du « Guide d’autodéfense numérique ».

    Jusqu'ici, seul le premier tome, qui se concentre sur l’utilisation d’un ordinateur « hors connexions » — on pourrait aussi bien dire préalablement à toute connexion, était disponible. Un second volume vient enfin le compléter. Il ambitionne de permettre à tout un chacun de comprendre quels sont les risques et les limites associés à l'utilisation d'Internet et de se donner les moyens de faire des choix éclairés quant à nos usages de l'Internet.

    Ce second tome est accompagné d'une troisième édition revue et corrigée du premier volume qui prend en considération les révélations concernant l'état actuel de la surveillance numérique ainsi que les dernières évolutions légales et techniques – et notamment les nouvelles versions des systèmes Debian et Tails.

    On trouve dans ce « Guide d'autodéfense numérique » enfin complet des éléments de compréhension de l’outil informatique et de ses failles, des éléments de réflexion permettant d’élaborer et de mettre en place des « politiques de sécurité » et des outils permettant à quiconque d’apprendre et de répandre des pratiques de protection appropriés à chaque situation.

    Pour en finir avec les illusions et les demi-solutions, apprenons et diffusons des pratiques d’autodéfense numérique !

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Catégories: Nouvelles du Libre

    Rentrée de l'association Linux-Alpes à Digne - jeudi 2 octobre

    mar, 16/09/2014 - 10:54

    Depuis 1999, Linux-Alpes, l'association des utilisateurs de logiciels libres dans les Alpes du sud (Alpes de Haute Provence et Hautes Alpes) organise des rencontres sur Digne, Gap, Veynes, parfois Sisteron, Manosque, Briançon, Villars-Colmars, Puimoisson, Peipin ou Forcalquier.

    À Digne, Linux-Alpes fait sa rentrée jeudi 2 octobre 2014 avec une nouvelle soirée d'échanges et de rencontres autour des logiciels libres. Rendez-vous à partir de 20h chez Xsalto, Rue Pasteur (plan d'accès) qui nous accueille à nouveau dans ses locaux cette année.

    Une autre soirée a lieu à Veynes vendredi 26 septembre à partir de 20h à l'espace Mul'OT, 10 rue Léon Cornand (plan d'accès).

    À Gap, les soirées ont repris dans les locaux du L.A.P., 5 rue léon Olphe Galliard depuis le mardi 9 septembre.

    Venez avec vos questions, vos pratiques à partager… en relation avec GNU-Linux et les logiciels libres. Ces soirées sont ouvertes à tous, l'entrée est libre et gratuite.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Catégories: Nouvelles du Libre

    Quelques nouvelles sur Qt et KDE

    mar, 16/09/2014 - 10:43

    Le nombre de dépêches sur KDE et Qt semble assez faible sur LinuxFr.org en comparaison du rythme effréné de l’actualité de ces deux projets libres en ce moment. Voici donc quelques nouvelles qui peuvent valoir la peine d'être lues.

    Évidemment, c’est loin d’être exhaustif et vous êtes invité à lire le très actif planetkde.org, si vous souhaitez plus de précisions.

    Sommaire Qt

    Pour rappel, Qt est la brique logicielle sur laquelle l'essentiel des logiciels KDE sont construits.

    Passage à la LGPL 3

    En 2009, Nokia a décidé d'ajouter la licence LGPL 2.1 à Qt, afin de faciliter son adoption dans plus de projets : la GPL, précédemment seule licence libre utilisée par le projet communautaire, a des contraintes car elle impose que tout projet dérivé soit également disponible sous la GPL. Cette année, Digia ajoutera la licence LGPL 3 à Qt 5.4 (les nouveaux modules ne disposeront pas de la LGPL 2.1). Son principal avantage est d'éliminer quelques faiblesses juridiques.

    Cette nouvelle licence facilitera la mise à disposition de modules sous licence libre ou propriétaire : Digia prévoyait initialement de garder les modules Qt Canvas3D (implémentation de WebGL pour Qt Quick) et Qt WebView (utilisation du moteur de rendu Web natif) pour la licence commerciale^Wpropriétaire, mais accepte de les diffuser sous la LGPL 3.

    Plus de détails sur le blog de Digia.

    Les versions commerciales^Wpropriétaires et communautaires de Qt se rapprochent

    Jusqu'à présent, les éditions commerciales de Qt sont présentées sur deux sites totalement distincts : qt.digia.com pour le commercial^Wpropriétaire, qt-project.org pour le libre. L'objectif est de fusionner ces deux sites, pour éviter la confusion et l’éparpillement entre les deux éditions.

    Plus de détails sur le blog de Digia.

    KDE

    KDE SC 4.14

    La version 4.14 de KDE SC a été annoncée le 20 août dernier. Comme dans la précédente version, aucune nouveauté majeure : les développeurs se sont concentrés sur divers petits détails, petites améliorations et corrections de bugs sous le capot. Les changements importants se font depuis un moment uniquement sur Plasma 5, KDE Frameworks 5 et KDE Applications 5.

    KF5

    Frameworks 5 a reçu sa première mise à jour le 7 août, puis la seconde le 12 septembre. Parmi les changements, KAuth a obtenu un nouveau dorsal (backend), on peut donc à nouveau ajouter des fonctionnalités qui requièrent l’accès superutilisateur, KWallet a obtenu un système de migration depuis sa version KDELibs 4, et la prise en charge des fichiers AppStream.

    Les développeurs de KF5 ont pris la décision controversée de ne plus faire de mises à jour de corrections de bugs et de faire des mises à jour mensuelles. Pour cela, tout est fait pour que les versions de développement de KF5 puissent être utilisées par les développeurs (dog fooding, i.e. de l'alimentation continue) et que les développeurs d’application contribuent à KF5. Il y aura également plus de tests automatisés, de revues par les pairs et des ajouts de fonctionnalités de manière plus fine.

    pyKDE5

    pyKDE5, c’est le binding pour utiliser KF5 depuis le langage de programmation Python. Pour le moment, les cadriciels suivants sont utilisables :

    • karchive ;
    • kcoreaddons ;
    • kguiaddons ;
    • kitemmodels ;
    • kitemviews ;
    • kplotting ;
    • kwidgetsaddons ;
    • solid ;
    • sonnet.

    Cela inclut la plupart des cadriciels de niveau 1, le plus gros manque étant KConfig. Certains petits cadriciels (comme kcodecs ou kwindowsystem) n’ont pas d’utilité depuis Python ou bien leur fonctionnalité y est déjà présente, ils n’ont donc pas de binding. D’autre part, seul Python 3 est géré (puisqu’il faut de toute façon faire le port de pyKDE4 à pyKDE5).

    (Note : le terme «  tier 1  » que j’utilisais dans la précédente dépêche est une traduction erronée ou, plutôt, une non-traduction, c’est pourquoi c’est maintenant traduit en «  niveau 1 »).

    Scripts de portage

    Les scripts de portages avaient été abordés dans la dépêche sur la sortie de KF5 et dans les commentaires.

    De nouveaux scripts sont disponibles :

    • convert-kdialog.pl aide au portage de KDialog vers QDialog (une classe de KDElib4Support utilisée par toutes les applications KDE), mais comme c’est une transition (et donc un script) plus compliquée que les autres, il faudra donc faire plus attention en vérifiant le résultat ;
    • autogenerate_export_header.sh va permettre de se passer de l'utilisation du fichier kdemacros.h, présent dans kdelibs4support, en générant directement les fichiers d'en-tête ;
    • convert-kcolordialog.pl aide au portage de KColorDialog::getColor vers QColorDialog::getColor (non ce n’est pas simplement un script d’une ligne) ;
    • convert-kcmdlineargs.pl sert quant à lui à la conversion de kcmdlineargs en aidant au portage de K4AboutData vers KApplication ;
    • convert-ktempdir.pl est chargé du portage de KTempDir vers QTemporaryDir ;
    • convert-ktemporaryfile.pl va s'occuper du portage de KTemporaryFile vers QTemporaryFile ;
    • convert-qt-os-macro.pl permet de remplacer Q_WS_* par Q_OS_* ;
    • convert-kdoublenuminput.pl s'occupe de migrer KDoubleNumInput vers QSpinBox ;
    • convert-kbuttongroup.pl aide au portage de kbuttongroup vers QGroupBox + QButtonGroup ;
    • convert-to-new-signal-slot-signal.pl est là pour le portage vers la nouvelle syntaxe des signaux et des slots de Qt5 ;
    • search-kdelibs4support-header.sh trouve les classes de KDElibs4Support de tous les fichiers d’un répertoire : il indique ce qu’il faut supprimer pour se débarrasser de KDElibs4Support.

    En outre, les scripts convert-kmenu.pl, convert-kmd5.pl, remove-kde4support.pl, convert-kcmdlineargs.pl, convert-kurl.pl et convert-kmimetype.pl ont été améliorés et, bien sûr, les autres ont reçu des corrections.

    Pour plus d’informations, vous pouvez consulter le blog de Laurent Montel, l’auteur de tous ces scripts : convert-kdialog.pl, port_to_autogenerate_export_header.sh and others, convert-ktemporaryfile.pl and co :), convert-kbuttongroup.pl, convert-to-new-signal-slot-signal.pl ? et clean-forward-declaration.sh?.

    Plasma

    Le 12 août dernier, Plasma 5 a reçu sa première mise à jour (correction de bogues). Concernant les plasmoïdes maintenus par l’équipe de Plasma, dans certains cas il faut complètement les réécrire. Mais c’est, par exemple, l’occasion de faire le nettoyage (pas la peine de porter un plasmoïde qui n’aurait pas de mainteneur par la suite). Pour plus d’informations, et .

    La prochaine version du plasmoïde NetworkManager pour Plasma 5 a reçu pas mal de changements sous le capot pour améliorer sa fiabilité et prendre en charge plus de configurations. Le port est presque fini, mais il n’y a pas de moniteur de trafic, celui-ci n’ayant pas encore été porté. De nouvelles notifications ont également été ajoutées pour les deux versions (Plasma 4 et 5) pour mieux informer l’utilisateur.

    Baloo

    À partir de Plasma 5.1, Baloo ne prend plus en charge FAT et les systèmes de fichiers réseau. Ne pouvant pas stocker les attributs (étiquettes, notes et commentaires) dans le système de fichier (via xattr), il a fallu trouver une solution de contournement : une base interne à Baloo. Elle est cependant mauvaise, car :

    • les informations sont stockées dans une base de données à part ;
    • ce n’est pas portable ;
    • il n'y a pas de mécanisme visible à l’utilisateur pour sauvegarder ou restaurer ces informations ;
    • cela fonctionne terriblement mal sur les systèmes de fichiers réseau car les informations sont stockées localement.

    Les développeurs ont préféré ne pas prendre en charge ces cas d’utilisation plutôt que de mal les gérer. En outre, cela a permis de grosses simplifications et d’améliorer le fonctionnement de Baloo. En effet, utiliser uniquement le système de fichiers local est très simple et rapide.

    En outre, il est maintenant possible de modifier ces informations avec une application tierce, sans perturber le fonctionnement de Baloo (il fallait auparavant mettre à jour la base de données interne de Baloo) et il est possible de surveiller et de réagir aux modifications.

    D’autre part, l’analyseur de requêtes naturelles (d’un précédent GSoC) a été porté sur KF5. Pour rappel, il permet d’effectuer facilement des requêtes très puissantes en langage naturel, telles que :

    GSoC

    Quelques projets et résultats des GSoC avancent bien et contribuent au dynamisme de KDE.

    Kpeople Adressbook est un carnet d’adresse pour KDE basé sur KPeople qui permet de consulter toutes les données et discussions d’un contact. On peut désormais, à l’issu du GSoC, consulter les clavardages, évènements, publications et fichiers d’une personne.

    OTR est maintenant disponible dans KTP (avec trois façons d’authentifier un pair, paramètres de politique OTR, gestion des empreintes connues et génération de clé privée par compte).

    KDE Connect est maintenant disponible sur iOS ! Il y a un dorsal et une interface graphique pour les plateformes iOS et les modules Ping, MPRIS, Partage de photo, synchronisation de presse-papiers, pavé tactile, et surveillance de la batterie.

    La prise en charge des fichiers Geogebra dans Kig, après avoir été réécrite plusieurs fois, est enfin fonctionnelle !

    KDevelopp a été bien amélioré ! L’intégration de Clang a été étendue pour pouvoir naviguer dans les macros C++ et passer de la déclaration à la définition d’un élément. D’autre part, la bibliothèque kdevplatformlanguage a été séparée en plusieurs parties plus faciles à maintenir, et elle compile maintenant sous Windows. Enfin, de nombreux bogues ont été corrigés.

    GCompris

    Depuis l'annonce en janvier dernier de la ré-écriture en Qt Quick, le projet a officiellement rejoint l'incubateur KDE. L'idée, à terme, est de compléter la liste des logiciels de KDE-Edu. Le portage avance bien : actuellement 80 activités sur les 140 de la version GTK+ ont été portées.

    Vous pouvez également en apprendre plus sur le blog de la bratcave.

    Autres Appel à contribution

    Ça fait quelques temps que votre serviteur essaie de vous tenir informé de l’actualité de KDE mais cette activité est vraiment chronophage. Alors, amateurs de KDE, n’hésitez pas à donner un coup de main en participant à la rédaction de dépêches et mettre en lumière les évolutions de KDE qui vous intéressent !

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Catégories: Nouvelles du Libre

    Revue de presse de l'April pour la semaine 37 de l'année 2014

    mar, 16/09/2014 - 10:40

    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

    [l'Humanité.fr] Conférence de Stallman: extraits choisis

    Par la rédaction, le samedi 13 septembre 2014. Extrait:

    Richard Stallman, le père du logiciel libre tenait ce vendredi une conférence sur les droits de l’homme et l’informatique. Morceaux choisis de la conférence.

    Lien vers l'article original: http://www.humanite.fr/conference-de-stallman-extraits-choisis-551619

    Et aussi:

    [Numerama] En Italie, Turin abandonne Windows pour Ubuntu

    Par Julien L., le vendredi 12 septembre 2014. Extrait:

    La ville de Turin a décidé de migrer son parc informatique vers Ubuntu. Outre des considérations économiques, la municipalité a pris en compte l'arrêt du support de Windows XP, l'expiration des licences et la vétusté des postes. Une économie de 300 euros par ordinateur est attendue.

    Lien vers l'article original: http://www.numerama.com/magazine/30541-en-italie-turin-abandonne-windows-pour-ubuntu.html

    Et aussi:

    [01net.] Numérique: les étonnantes nominations de la Commission européenne

    Par Pascal Samama, le jeudi 11 septembre 2014. Extrait:

    Jean-Claude Juncker, a présenté son équipe. Les nouveaux responsables du numérique sont loin d’être des spécialistes. Bonne nouvelle pour les géants du Net, moins bonne pour l’Europe numérique. Portraits.

    Lien vers l'article original: http://www.01net.com/editorial/626674/numerique-les-etonnantes-nominations-de-la-commission-europeenne

    Et aussi:

    [Numerama] Neutralité du net: le congrès américain submergé par les appels

    Par Julien L., le jeudi 11 septembre 2014. Extrait:

    Dans le cadre d'une journée d'action en faveur de la neutralité du net aux USA, de nombreux sites web ont lancé une opération visant à simuler un Internet lent. En outre, les Américains se sont mobilisés pour convaincre leurs élus de se mobiliser sur ce sujet. Le congrès a été submergé par les appels au cours de la journée.

    Lien vers l'article original: http://www.numerama.com/magazine/30528-neutralite-du-net-le-congres-americain-submerge-par-les-appels.html

    Et aussi:

    [Le Monde.fr] Le Conseil d'Etat veut un encadrement des activités des espions sur Internet

    Par Martin Untersinger, le mardi 9 septembre 2014. Extrait:

    Le Conseil d’Etat présente, mardi 9 septembre, son étude annuelle, consacrée cette année au numérique et aux droits fondamentaux. C’est loin d’être le premier rapport que l’administration produit à propos du numérique. Mais l’étude annuelle de la plus haute juridiction administrative française, qui fait généralement référence, est toujours étudiée de près par les professionnels du droit et les milieux du domaine concerné.

    Lien vers l'article original: http://www.lemonde.fr/pixels/article/2014/09/09/le-conseil-d-etat-veut-un-encadrement-des-activites-des-espions-sur-internet_4484206_4408996.html

    Et aussi:

    Voir aussi:

    [Les Echos] Imbroglio sur la réforme du copyright

    Par Charles Cuvelliez, le mardi 9 septembre 2014. Extrait:

    La Commission européenne a lancé une vaste consultation sur la réforme du copyright qui a recueilli 9 500 contributions d'utilisateurs et de consommateurs… Et personne n'est d'accord.

    Lien vers l'article original: http://www.lesechos.fr/idees-debats/cercle/cercle-108516-copyright-les-usagers-sont-sur-venus-tous-les-autres-sur-mars-1040594.php

    Et aussi:

    [Direction Informatique] Le logiciel libre à la Gendarmerie française

    Par Jean-François Ferland, le lundi 8 septembre 2014. Extrait:

    La Gendarmerie nationale, qui est responsable de la sécurité dans les zones rurales et les banlieues dans la France et ses territoires – l’équivalent en quelque sorte de la Sureté du Québec – a réalisé au cours des années 2000 un projet de grande envergure: la migration de dizaines de milliers de postes de travail au moyen de logiciels libres.

    Lien vers l'article original: http://www.directioninformatique.com/le-logiciel-libre-a-la-gendarmerie-francaise-1-alibi-pour-une-independance-technologique/30069

    [Framablog] Internet. Pour un contre-ordre social

    Par Christophe Masutti, le vendredi 5 septembre 2014. Extrait:

    Depuis le milieu des années 1980, les méthodes de collaboration dans la création de logiciels libres montraient que l’innovation devait être collective pour être assimilée et partagée par le plus grand nombre. La philosophie du Libre s’opposait à la nucléarisation sociale et proposait un modèle où, par la mise en réseau, le bien-être social pouvait émerger de la contribution volontaire de tous adhérant à des objectifs communs d’améliorations logicielles, techniques, sociales.

    Lien vers l'article original: http://www.framablog.org/index.php/post/2014/09/05/internet-pour-un-contre-ordre-social-christophe-masutti

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Catégories: Nouvelles du Libre

    Je crée mon jeu vidéo E13 : un an, premier bilan

    mar, 16/09/2014 - 07:44

    « Je crée mon jeu vidéo » est une série d'articles sur la création d'un jeu vidéo, depuis la feuille blanche jusqu'au résultat final. On y parle de tout : de la technique, du contenu, de la joie de voir bouger des sprites, de la lassitude du développement solitaire, etc. Vous pourrez suivre cette série grâce au tag gamedev.

    Dans l'épisode 12, on a parlé des interfaces graphiques et physiques. Dans cet épisode anniversaire, on va faire un premier bilan global de l'état du jeu. Et on discutera aussi d'autres événements liés aux jeux vidéos et qui me concernent et en quoi ça peut aider Akagoria.

    Sommaire Akagoria au bout d'un an

    Il y a un an le 16 septembre 2013 était publié le premier épisode de cette série. Et même si Akagoria est né sans doute un peu avant, on peut considérer que sa date de naissance est bien ce premier épisode. Bon, ok, j'ai releasé early, mais pas très often il faut bien l'avouer. Au départ, je me suis donné deux à trois ans pour mener à bien cette aventure. Un an s'est déjà écoulé et je pensais que j'aurais avancé plus que ça. Donc, on va dire plutôt trois ans.

    Les réussites

    Dans ce qui a bien fonctionné, il y a tout d'abord ces épisodes. Douze épisodes ont été publiés de manière irrégulière mais cela me force à avancer, c'est un motivateur assez puissant. Ils me permettent de partager mes trouvailles, mais aussi de mettre de l'ordre dans mes pensées et de les concrétiser quand il le faut. Et c'est important parce qu'entre une idée dans un TODO et sa réalisation, il y a souvent un delta non négligeable et ça peut prendre plus de temps que prévu. En plus, ces épisodes me permettent de me poser la question : quelle est la prochaine étape ? J'ai à peu près toujours un ou deux épisodes en tête pour le futur quand je publie un nouvel épisode. Là par exemple, je sais ce que sera le prochain, et je sais ce qu'il me reste à faire pour qu'il puisse sortir. Yapluka. Voici donc la liste des douze épisodes pour ceux qui veulent faire du replay :

    Je me suis permis de faire quelques statistiques sur ces épisodes. Sur le graphique suivant, on peut voir le nombre de pertinentages et le nombre de commentaires pour chaque épisode. On voit qu'il n'y a pas vraiment de corrélation entre les deux. Les moyennes sont respectivement de 50 et 51 mais cachent en fait de grandes disparités avec quelques épisodes qui font beaucoup monter la moyenne. La leçon de ces chiffres, c'est que ces épisodes vous plaisent et que vous y êtes fidèles.

    L'autre réussite de cette première année, c'est d'avoir publié pas mal de code. Je n'avais jamais vraiment publié de code publiquement auparavant et montrer son code au monde entier, ça force vraiment à faire les choses à peu près bien, à mettre de la doc, etc. Je suis plutôt satisfait d'avoir réussi à produire ces codes-sources là. Bien sûr, ils sont perfectibles mais ils permettent déjà d'avoir quelques briques de base. Les bibliothèques notamment sont largement réutilisables par d'autres jeux. Voici les bouts de code produits :

    • libes, une bibliothèque pour gérer les systèmes à entités. Cette bibliothèque se stabilise doucement mais sûrement ;
    • libtmx, une bibliothèque pour lire le format TMX de Tiled, plutôt stable pour l'instant (en attendant les évolutions du format lors de la prochaine sortie de Tiled) ;
    • libsuit, une bibliothèque d'entrées physiques et de widgets, encore en développement et qui suivra les besoins du jeu au fur et à mesure ;
    • MapMaker est un logiciel de création de carte d'altitude, dont la partie commune est stable mais dont la partie spécifique à Akagoria est encore en développement, car je ne suis pas encore satisfait de la manière de construire la carte primitive ;
    • SlowTree est un logiciel de génération procédurale de sprite en vue de haut, encore en développement car je veux continuer à explorer certaines pistes pour certains types de sprites.

    J'en profite pour remercier tous les contributeurs occasionnels à ces projets et particulièrement Sébastion Rombauts qui a contribué à libes et à MapMaker grâce à de nombreux patchs. Grâce à lui, vous aurez une version sans bug du bruit à base de simplexe dont on avait parlé dans l'épisode 10 et qui avait manifestement un bug.

    Les difficultés

    Dans le moins bon, je n'ai sans doute pas avancé autant que je l'espérais au départ. Dans ma tête, j'étais parti sur un planning de deux ans avec un développement important du code la première année, et un développement du reste ensuite (scénario, dialogues, sprites, musiques, etc). Or, le code est très très loin d'être opérationnel pour commencer à développer activement le reste.

    Comment expliquer ce retard ? Tout d'abord, le temps est une denrée très aléatoire quand on développe un jeu amateur. À l'automne dernier, j'ai eu pas mal de temps libre et donc j'en ai beaucoup profité pour avancer sur plein de fronts. Mais à partir de début 2014, j'ai baissé le rythme drastiquement, en partie à cause d'une activité professionnelle plus prenante (y compris sur mes week-ends), en partie parce que j'ai fait un peu de hors pistes en allant explorer des choses complètement inutiles pour mon jeu. Je voyais le temps défiler et j'étais dans l'incapacité d'avancer convenablement. C'était très frustrant.

    Retour sur les choix techniques

    Au bout d'un an, il est temps de revenir sur les choix techniques faits au départ pour se demander s'ils sont pertinents.

    Commençons par le plus simple. Il y a des choix que je ne regrette pas : SFML, Box2D, TMX. Ces trois technologies sont très efficaces et répondent bien au besoin d'un jeu amateur. SFML est une excellente abstraction et, même si on aimerait qu'elle soit un peu plus complète, j'apprécie sa simplicité et sa documentation riche et utile. Box2D est également une excellente bibliothèque, assez simple à prendre en main. On arrive à faire ce qu'on veut, même si parfois on se demande si la manière dont on procède est bien la bonne manière de faire. TMX enfin, avec son éditeur Tiled, est un format qui me donne vraiment entière satisfaction. Sa généricité n'empêche pas qu'on puisse le spécialiser comme on le souhaite via son système de propriétés. En fait, le plus difficile dans ces trois choix est de les faire cohabiter intelligemment.

    Finissons par le choix d'utiliser les systèmes à entités. Là, je dois dire qu'au bout d'un an, je reste perplexe. D'un côté, je vois bien que théoriquement, ce paradigme n'offre que des avantages (en particulier dans le style de jeu que je vise). D'un autre côté, dans la pratique, c'est assez complexe. Ce qui est dur, c'est de bien délimiter les systèmes en fonctionnalités et de choisir les bons composants. Qu'est-ce qui relève de l'état du jeu, qu'est-ce qui relève de données statiques ? La frontière est mince et mouvante. Ce qui serait simple, ce serait d'avoir déjà l'ensemble des systèmes et l'ensemble des composants. Construire les bons systèmes et les bons composants quand on part de zéro et qu'on n'a quasiment aucun modèle, c'est très compliqué. Je pense que j'aurais été beaucoup plus vite pour développer mon jeu avec un paradigme objet plus traditionnel. Mais je pense que je vais rester sur les systèmes à entités pour aller jusqu'au bout de l'expérimentation et contruire un jeu complet avec ce paradigme.

    Perspectives

    Quelles sont les perspectives ? Tout d'abord, il faut que j'arrive à finir le code (ou en tout cas une partie suffisamment importante du code) pour commencer le contenu du jeu. Je pense que je vais passer en mode sale pour le code qui reste à faire. Comprendre par là que je préfère avoir un code qui marche mais pas tout à fait nickel plutôt que d'essayer à tout prix d'avoir un code propre et bien pensé. En un mot : fonctionnalités plutôt que réutilisabilité. J'espère que dans un an, pour le deuxième anniversaire, on y sera.

    L'autre point important, c'est d'avancer sur les sprites. Pour l'instant, Naha m'en a fait quelques uns qui sont plutôt réussis. Il va falloir continuer et sans doute accélérer un peu le rythme parce qu'il manque encore beaucoup de choses à ce niveau. J'aimerais pouvoir générer tout un tas de choses sur la carte primitive et qu'on puisse la modifier facilement sans devoir passer du temps à des tâches répétitives. Par exemple, pour définir une forêt, il est plus simple de tenter de la générer (éventuellement en guidant cette génération) plutôt que de placer les arbres un à un.

    Ma première GameJam

    J'ai participé à ma première game jam au début de l'été. C'était un moment fort enrichissant à plusieurs niveaux. Pour ceux qui ne savent pas ce qu'est une game jam, c'est une sorte de concours en temps limité où le but est de développer un jeu.

    Cette game jam, baptisée Game Cancoillote, et organisée par deux de mes étudiants, s'est déroulé fin juin sur un week-end, dans les locaux de l'Université de Franche-Comté. Ils avaient bien fait les choses, on avait une grande salle pour toutes les équipes, et bien sûr à manger et à boire, ce qui a favorisé une excellente ambiance !

    Il y avait cinq équipes qui ont utilisé des technologies très différentes. Une équipe a utilisé GameMaker, une autre Java, une autre HTML5/JS, une autre un moteur de jeu propriétaire, et la dernière, la mienne, a utilisé ce bon vieux couple C++/SFML. Même au niveau des concepts de jeu, il y a eu quelques surprises. Celui que j'ai préféré était l'équipe HTML5/JS qui a fait un jeu d'aventure en pointer-et-cliquer. Ils ont imaginé un scénario par rapport au thème de la game jam et ont utilisé l'université comme décor. Ils ont pris des photos panoramiques de divers endroits, ils ont aussi utilisé certaines vues de Google Maps (ouais, problème de copyright toussa). Et ensuite, ils ont incrusté un personnage en dessin. Et bien ça rend plutôt bien.

    Pour ma part, j'étais dans une équipe composée de cinq personnes : trois étudiants (la major d'une spécialité de Master, le major et le second de licence 3) et deux profs (une collègue et moi-même). Sur le papier, une très bonne équipe. Deux des étudiants avaient déjà fait un jeu (dont un en projet semestriel avec moi), mais ma collègue était une novice complète. On avait déjà réfléchi à une idée globale de jeu avant la game jam tout en sachant que nous allions devoir nous adapter au thème (non-connu à l'avance) de la game jam. Notre idée était de partir sur le principe de pierre-feuille-ciseaux avec trois machins qui lutteraient les uns contre les autres.

    Ce qui est bien, c'est que l'adaptation a été simple. Le thème de la game jam était une équation qui disait en gros qu'il fallait qu'il y ait de la physique dans le jeu et qu'il ne devait pas y avoir de gagnant dans le jeu. Nous avons alors imaginé qu'on pouvait avoir un jeu solo (donc pas de gagnant) où on contrôle une boule représentant une des trois entités et qu'on serait au milieu d'une sorte d'arène en train d'éviter ou de chasser les boules des autres entités qui arriveraient au hasard. Chaque rencontre donnerait lieu à une collision et une réaction : la disparition d'une boule en cas d'entités différentes. Et pour le fun, on a pris une variante japonaise : le guerrier, le tigre et la mère du guerrier. Voilà à quoi ça ressemble :

    Au final, ce n'est pas si mal que ça pour le temps imparti. Nous n'avons pas eu trop de difficultés. Nous avons utilisé Box2D pour la physique (même si on aurait pu développer le moteur physique nous-même dans ce cas simple). Les avatars de chaque camp utilisent des photos prises dans la grande toile et j'aimerais bien les modifier pour pouvoir publier le jeu correctement sans avoir de problème de copyright. En revanche, l'illustration en bas à droite est l'œuvre d'une graphiste présente à la gam jam et qui a fait quelques dessins pour toutes les équipes (elle était très demandée).

    Pour la beauté du geste, on a même fait un écran d'accueil avec cette même illustration.

    Au niveau du nom, nous n'avons pas été très originaux. Une fois que tout sera d'aplomb niveau copyright, j'essaierai d'imaginer un nouveau nom (ou si vous avez des idées, n'hésitez pas à les partager en commentaire).

    Un club de développement de jeu vidéo

    La grosse nouveauté pour moi cette année, c'est que je lance dans mon université un club de développement de jeux vidéo. Je l'ai baptisé Dead Pixels Society. L'idée est de faire un jeu vidéo sur l'année universitaire avec une équipe d'une dizaine d'étudiants (pas forcément uniquement des informaticiens d'ailleurs) de tous niveaux.

    Je ne sais pas ce que ça peut donner, mais j'ai des étudiants déjà très motivés par cette idée. Évidemment, j'espère aussi initier des étudiants complètement novices aux arcanes du développement d'un jeu vidéo. Pour cela, j'ai réalisé quelques fiches sur des aspects techniques basiques d'un jeu vidéo : la boucle de jeu, les systèmes de coordonnées 2D, les couleurs et la transparence, les sprites et animations, les moteurs physiques, etc. L'idée est de faire passer quelques concepts sans entrer dans les détails et sans s'attacher à une technologie en particulier. J'ai encore quelques idées de fiches mais je crois avoir brossé une bonne partie du sujet. Si vous avez des suggestions, n'hésitez pas à m'en faire part en commentaire.

    J'aurai sans doute l'occasion de revenir sur les activités de ce club au cours des prochains épisodes ou dans des journaux. Si nous arrivons à enrichir le paysage des jeux libres d'un nouveau jeu par an, je me dis qu'on aura réussi quelque chose de bien. Cette activité parallèle à Akagoria va aussi sans doute me permettre d'avancer sur mon propre jeu. Outre le fait que j'ai maintenant un créneau fixe chaque semaine consacré au développement de jeux vidéo, il y a aussi les idées (et les bouts de code) qui peuvent émerger dans un autre jeu et dont je pourrai me resservir.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Catégories: Nouvelles du Libre

    Mons, le 18 septembre 2014 : MOOC – une façon ouverte d’apprendre librement ?

    dim, 14/09/2014 - 22:48

    Ce jeudi 18 septembre 2014 à 19h se déroulera la 31ème séance montoise des Jeudis du Libre de Belgique.

    MOOC (Massive Open Online Course / Cours en ligne ouverts à tous) : une façon ouverte d’apprendre librement ? Exemples avec ITyPa (sujet généré par les participants) et « Khan Academy » (sujet classique exposé par un professeur)

    • Thématique : e-Learning
    • Public : Tout public
    • Animateurs conférenciers :

      • Philippe Verstichel (Académie du Management)
      • Bruno De Lièvre (UMONS, Faculté de Psychologie et des Sciences de l’Éducation)
    • Lieu de cette séance : Campus technique (ISIMs) de la Haute Ecole en Hainaut, Avenue V. Maistriau, 8a, Salle Académique, 2e bâtiment (cf. ce plan sur le site de l’ISIMs, et ici).

    Description : Voyage au pays des MOOC (Massive Open Online Course), cours en ligne qui autorisent de nouvelles façons d’apprendre mais également, dans l’esprit du “Libre”, de nouvelles façons de développer non pas des programmes informatiques mais des contenus éducatifs communs.

    Dans une première partie, le concept est expliqué de manière pratique au travers d’exemples bien choisis pour mettre en relief les différences entre les plateformes. Du traditionnel « coursera » au connectiviste « ITyPa » en passant par le concept de la « Khan Academy ».

    Au cours de la deuxième partie, à côté d’une nouvelle approche de l’enseignement à distance, l’exposé dévoilera l’extraordinaire possibilité des MOOC comme outil de co-création de connaissance et de supports éducatifs. Au delà des défis technologiques engendrés, le caractère collaboratif/participatif des MOOC requiert en effet de nouvelles approches aussi bien en matière de pédagogie que de fabrication de contenu (celle-ci pouvant se rapprocher des développements de logiciels libres).

    Dans la dernière partie, nous aborderons le côté pratique au travers de deux outils. L’un, Moodle, est utilisé par l’Université de Mons et la Haute École Condorcet, et l'autre : OpenMOOC

    La présentation se terminera par un débat interactif sur les potentiels des MOOC en Wallonie et sur leurs apports possibles dans des milieux universitaires, entrepreneuriaux ou en formation continue.
    La participation sera gratuite et ne nécessitera que votre inscription nominative, de préférence préalable, ou à l’entrée de la séance. La séance sera suivie d’un verre de l’amitié.

    Les Jeudis du Libre à Mons bénéficient aussi du soutien de nos partenaires : Normation, MeaWeb, NextLab et Phonoid.

    Si vous êtes intéressé(e) par ce cycle mensuel, n’hésitez pas à consulter l’agenda et à vous inscrire sur la liste de diffusion afin de recevoir systématiquement les annonces.

    Pour rappel, les Jeudis du Libre se veulent des rencontres autour de thématiques des Logiciels Libres. Les rencontres montoises se déroulent chaque troisième jeudi du mois, et sont organisées dans des locaux et en collaboration avec des Hautes Écoles et Facultés Universitaires du Pôle Hainuyer d’enseignement supérieur impliquées dans les formations d’informaticiens (UMONS, HEH et Condorcet), et avec le concours de l’A.S.B.L. LoLiGrUB, active dans la promotion des logiciels libres.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Catégories: Nouvelles du Libre

    Mons, le 18 septembre : MOOC – Une façon OUVERTE d’apprendre LIBREMENT ?

    dim, 14/09/2014 - 22:48

    Ce jeudi 18 septembre 2014 à 19h se déroulera la 31ème séance montoise des Jeudis du Libre de Belgique.

    MOOC (Massive Open Online Course / Cours en ligne ouverts à tous) : une façon ouverte d’apprendre librement ? Exemples avec ITyPa (sujet généré par les participants) et « Khan Academy » (sujet classique exposé par un professeur)

    • Thématique : e-Learning
    • Public : Tout public
    • Animateurs conférenciers :

      • Philippe Verstichel (Académie du Management)
      • Bruno De Lièvre (UMONS, Faculté de Psychologie et des Sciences de l’Éducation)
    • Lieu de cette séance : Campus technique (ISIMs) de la Haute Ecole en Hainaut, Avenue V. Maistriau, 8a, Salle Académique, 2e bâtiment (cf. ce plan sur le site de l’ISIMs, et ici).

    Description : Voyage au pays des MOOC (Massive Open Online Course), cours en ligne qui autorisent de nouvelles façons d’apprendre mais également, dans l’esprit du “Libre”, de nouvelles façons de développer non pas des programmes informatiques mais des contenus éducatifs communs.

    Dans une première partie, le concept est expliqué de manière pratique au travers d’exemples bien choisis pour mettre en relief les différences entre les plateformes. Du traditionnel « coursera » au connectiviste « ITyPa » en passant par le concept de la « Khan Academy ».

    Au cours de la deuxième partie, à côté d’une nouvelle approche de l’enseignement à distance, l’exposé dévoilera l’extraordinaire possibilité des MOOC comme outil de co-création de connaissance et de supports éducatifs. Au delà des défis technologiques engendrés, le caractère collaboratif/participatif des MOOC requiert en effet de nouvelles approches aussi bien en matière de pédagogie que de fabrication de contenu (celle-ci pouvant se rapprocher des développements de logiciels libres).

    Dans la dernière partie, nous aborderons le côté pratique au travers de deux outils. L’un, Moodle, est utilisé par l’Université de Mons et la Haute École Condorcet, et l'autre : OpenMOOC

    La présentation se terminera par un débat interactif sur les potentiels des MOOC en Wallonie et sur leurs apports possibles dans des milieux universitaires, entrepreneuriaux ou en formation continue.
    La participation sera gratuite et ne nécessitera que votre inscription nominative, de préférence préalable, ou à l’entrée de la séance. La séance sera suivie d’un verre de l’amitié.

    Les Jeudis du Libre à Mons bénéficient aussi du soutien de nos partenaires : Normation, MeaWeb, NextLab et Phonoid.

    Si vous êtes intéressé(e) par ce cycle mensuel, n’hésitez pas à consulter l’agenda et à vous inscrire sur la liste de diffusion afin de recevoir systématiquement les annonces.

    Pour rappel, les Jeudis du Libre se veulent des rencontres autour de thématiques des Logiciels Libres. Les rencontres montoises se déroulent chaque troisième jeudi du mois, et sont organisées dans des locaux et en collaboration avec des Hautes Écoles et Facultés Universitaires du Pôle Hainuyer d’enseignement supérieur impliquées dans les formations d’informaticiens (UMONS, HEH et Condorcet), et avec le concours de l’A.S.B.L. LoLiGrUB, active dans la promotion des logiciels libres.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Catégories: Nouvelles du Libre

    Apéro+workshops Python (Flask et AsyncIO) à Mons (BE) - le 2 Octobre

    dim, 14/09/2014 - 07:56

    Amis Pythonistes, notez la date du prochain AFPyro (et venez-y) ! Le prochain Apero Python Belgium se tiendra le jeudi 2 Octobre à Mons, lors de la Quizaine Numérique de Mons, du 27 septembre au 19 octobre. En plus des habitués de l’AFPyro, nous accueillerons des débutants en Python afin de leur présenter la puissance du langage. Vous pourrez ainsi participer à un des deux workshops proposés en parallèle, l'un sur Flask, l'autre sur AsyncIO (détails en seconde partie). N’oubliez pas de prendre votre ordinateur portable si vous voulez participer au workshop. Bien entendu (car c’est dans le nom), un apéro sera également organisé pendant l’événement.

    Rendez-vous à partir de 18h30, à Co-nnexion, Espace de Coworking, 2b Rue des Archers, 7000 Mons.

    Deux workshops sont proposés en parallèle :

    1. Pour les Pythonistes débutants, un workshop pour apprendre les bases de Python, puis pour construire une application Web avec Flask.
    2. Pour les développeurs avancés, une initiation à AsyncIO, suivie d’un exemple concret d’une API REST/JSON asynchrone avec AsyncIO, aiohttp, aiorest et aiopg. Enfin, un benchmark sera réalisé afin de comparer les performances avec une API REST/JSON synchrone en Flask.
    Télécharger ce contenu au format Epub

    Lire les commentaires

    Catégories: Nouvelles du Libre

    Atelier Tmux à Bordeaux le 15 septembre 2014

    sam, 13/09/2014 - 11:36

    Lundi 15 septembre 2014 se tiendra le premier atelier CLI, sur Tmux, un multiplexeur de terminal. Le but de ces ateliers, proposés par des membres d’associations et collectifs Bordelais, est de progresser ensemble sur un outil ou un thème, toujours en ligne de commande. Les ateliers "spécial débutants" reprendront le 13 octobre.

    Cet atelier se déroulera dans les locaux du L@BX dans la fabrique POLA.

    NdM : merci à xaccrocheur pour les liens.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Catégories: Nouvelles du Libre