Syndiquer le contenu
Mis à jour : il y a 16 heures 16 min

Présentation et Installation Emmabuntüs et Logiciels Libres - Septembre 2014 Montpellier-Saint-Aunès

10 septembre, 2014 - 08:35

Samedi 13 septembre 2014 de 14h00 à 17h30
Communauté Emmaüs Montpellier-Saint-Aunès
La Vieille Cadoule 34130 Saint-Aunès
GPS Latitude : 43.649363 | Longitude : 3.991591

Rendez-vous le deuxième samedi de chaque mois.

L’équipe de Montpel’libre vous donne rendez-vous chez Emmaüs pour une journée d’information et de sensibilisation à l’utilisation des Logiciels Libres. Nous vous présenterons Ubuntu et bien sûr l’une de ses dérivées Emmabuntüs.

Pourquoi venir ?

Vous désirez un ordinateur à votre service ?
Vous désirez un ordinateur qui va vite ?
Vous désirez un ordinateur qui ne communique aucune données à des inconnus ?
Vous désirez un ordinateur qui n’a pas besoin d’antivirus ?

Vous rencontrerez des personnes qui sont là pour vous parler de Logiciels Libres.
Vous pourrez aussi acheter des ordinateurs déjà installés prêt à être utilisés.

Comment venir ?

Un covoiturage est organisé au départ de la rue du Faubourg de Nîmes à 11h00.

Télécharger ce contenu au format Epub

Lire les commentaires

ConFoo: La conférence pour les développeurs web est à la recherche de conférenciers.

9 septembre, 2014 - 15:02


ConFoo est à la recherche de professionnels du web avec une connaissance approfondie du développement avec PHP, Python, Ruby, Java, DotNet, HTML5, Databases, Cloud et le dévelopement mobile souhaitant partager leurs connaissances et expériences lors du prochain ConFoo. Soumettez vos propositions entre le 25 août et le 22 septembre.

  • ConFoo 2015 se déroulera du 18 au 20 février à Montréal, à l’Hôtel Hilton Bonaventure.
  • Nous prenons grand soin de nos conférenciers en couvrant la majorité des dépenses incluant le déplacement, l’hébergement, le lunch, le billet complet de la conférence, etc.
  • Les présentations sont d’une durée de 35min + 10min 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 290$ en vigueur jusqu’au 13 octobre.

Télécharger ce contenu au format Epub

Lire les commentaires

Sortie de PHP 5.6

9 septembre, 2014 - 10:18

Ultime version de la branche 5.x, PHP 5.6.0 apporte quelques possibilités de développement, un débogueur interactif et corrige quelques 150 bogues.

Les principales nouveautés sont :

  • Les expressions de constantes scalaires
  • Fonctions à nombre d'arguments variable ainsi que l'opérateur ... pour empaqueter/dés-empaqueter les arguments
  • L'opérateur ** pour l'exponentiation
  • L'extension du mot-clé use pour importer les fonctions et les constantes
  • Un débogueur interactif : phpdbg intégré comme module SAPI.
  • La ré-utilisabilité de php://input faisant passer $HTTP_RAW_POST_DATA en déprécié.
  • Les objets GMP (GNU Multiple Precision) supportent maintenant la surcharge des opérateurs et le transtypage en types scalaires.

Plus de détails sont disponibles dans la suite de cette dépêche.

Sommaire Nouveautés Les expressions de constantes scalaires

Il est maintenant possible de définir des constantes d'après le résultat d'opérations effectuées sur d'autres constantes. Il est également possible de les utiliser dans les déclarations de propriété et dans les arguments par défaut de fonctions.

Exemple tiré du site php.net :

const UN = 1; const DEUX = UN * 2; class C { const TROIS = DEUX + 1; const UN_SUR_TROIS = UN / self::TROIS; const RESULTAT = 'La valeur de TROIS est '.self::TROIS; public function f($a = UN + self::TROIS) { return $a; } } echo (new C)->f()."\n"; echo C::RESULTAT;

Résultat :

4
La valeur de TROIS est 3

Fonctions à nombre d'arguments variable

Les fonctions PHP peuvent accepter un nombre d'arguments variable, ceux-ci seront contenus dans un tableau défini grâce à l'opérateur …

Exemple :

function somme($arg1, $arg2 = null, ...$args){ //$args est un array contenant les arguments restants //$count($args) représente le nombre d'arguments dans $args return $arg1+$arg2+array_sum($args); } somme(1); somme(1,2); somme(1,2,3,4);

A noter que l'on peut utiliser le typage explicite.

Dés-empaquetage des objets

L'opérateur ... peut aussi être utilisé lors de l'appel de fonction pour dés-empaqueter un tableau ou tout objet parcourable par foreach.

Exemple tiré du site php.net :

function add($a, $b, $c) { return $a + $b + $c; } $operators = [2, 3]; echo add(1, ...$operators); L'opérateur ** pour l'exponentiation

L'opérateur ** représente l'exponentiation, l'opérateur **= est utilisé pour l'assignation.

Exemple :

$a = 2**3**2; // $a = 512 $a **= 5; // $a = 35184372088832

Attention, cet opérateur est associatif à droite :
2 ** 3 ** 2 est équivalent à 2 ** (3 ** 2).

Extension du mot-clé use

Depuis PHP 5.3, il est possible d'importer des classes avec l'opérateur use.
Il est maintenant possible d'importer des fonctions ou des constantes.

Exemple tiré du site php.net :

namespace Name\Space { const FOO = 42; function f() { echo __FUNCTION__."\n"; } } namespace { use const Name\Space\FOO; use function Name\Space\f; echo FOO."\n"; f(); } phpdbg

Utilisable pour PHP >= 5.4 et inclus dans PHP 5.6, phpdbg est un débogueur complet utilisable sans impact sur les performances ni sur les fonctionnalités du code.

Son objectif est d'être léger, puissant et simple à utiliser.

Ré-utilisabilité de php://input

Les flux php:// sont des flux d'entrée/sortie fournis par PHP. Le flux php://input permet d'accéder en lecture seule aux données brutes depuis le corps de la requête.

Dans le cas de requêtes POST, il se substitue maintenant à la variable $HTTP_RAW_POST_DATA qui nécessitait l'activation de always_populate_raw_post_data boolean dans le php.ini pour inclure les type MIME reconnus.

Utilisation :

$postdata = file_get_contents("php://input");

Ce nouveau mécanisme a également permis de réduire significativement la quantité de mémoire requise lors des opérations POST.

Problèmes de compatibilité

Quelques incompatibilités sont à prévoir pour cette nouvelle version. Comme à l'accoutumée, il est conseillé de lire (en anglais) la page de migration de php5.5 vers php5.6.

Les principales incompatibilités se situent au niveau des changements OpenSSL :
Tous les flux clients chiffrés activent désormais par défaut la vérification par paire.

A noter également, la fonction json_decode sera légèrement plus stricte puisque les inputs true, false et null seront refusés s'ils ne sont pas entièrement en minuscule.

Le Futur PHP7

PHP s'oriente vers la version 7. Après quelques débats, il a été choisi de sauter la version 6. En effet, ce projet échoué, devant notamment rendre PHP entièrement compatible avec Unicode, possédait trop de référence et de livres consacrés. Les principales nouveautés de PHP6 ont d'ailleurs déjà été incluses au fil de l'eau dans >= PHP5.3. PHP7 n'a définitivement pas les même objectifs.

PHPNG et compilation à la volée

Comme expliqué ici (en anglais), PHP7 repart sur les bases de PHPNG. Concrètement, il s'agit avant tout de se doter d'un nouveau moteur bien plus performant que le Zend Engine actuel.

Ce gain de performance pourra être accentué par le compilation à la volée (JIT : Just In Time) qui devrait être implémenté par Dmitry Stogov. Il annonce 10 à 20 pourcent de vitesse en plus sur des applications réelles : Wordpress 3.6 (+20%), Dupral 6.1 (+11.7%) …

Syntaxe d'arbre abstraite

Quelques changements de syntaxe et de fonctionnement du compilateur pourrait également être inclus dans la version 7 pour profiter de performances encore supérieures.

PHP vs HACK

Le langage HACK et sa machine virtuelle HHVM ont été dévoilés il y a quelques mois par Facebook. Une dépêche avait été publiée pour l'occasion. En grande partie compatible avec PHP, ce langage apporte notamment le typage statique, l'écriture de squelettes HTML protégés des failles XSS, la programmation asynchrone. HHVM, quant-à-elle, propose la compilation à la volée et peut faire tourner du PHP.

Il ne fait aucun doute que ce sera un concurrent très sérieux pour PHP et que cela incitera ses mainteneurs à le faire évoluer rapidement pour ne pas se laisser distancer.

Télécharger ce contenu au format Epub

Lire les commentaires

Salut à Toi, version 0.5

9 septembre, 2014 - 09:07

Nous sommes heureux de vous annoncer la sortie de Salut à Toi, version 0.5. Nous nous sommes cette fois-ci concentrés sur la sécurité et le ré-usinage de certains mécanismes qui vont faciliter l'ajout de futures fonctionnalités et la maintenance.

Pour rappel SàT est un client XMPP multi-usages et multi-interfaces principalement développé en Python. Les interfaces les plus avancées sont Primitivus (console) et Libervia (web), Jp (ligne de commande) facilite les tâches d'administration, Wix (bureau/WxWidgets) est vouée à disparaître et sera remplacée par Bellaciao (bureau/Qt). Une interface pour Android est également prévue.

Sommaire

Sécurité

Un nouveau paramètre a été ajouté pour définir un mot de passe pour le profil SàT, qui est stocké haché dans la base de données. Sa version claire permet de sécuriser les autres mots de passe, dont celui du compte XMPP, qui sont eux chiffrés dans la base. Un schéma détaille comment tout ça fonctionne sur le wiki du projet : chiffrement.

Libervia supporte désormais le HTTPS. L'administrateur peut choisir quel(s) service(s) activer : HTTP, HTTPS ou les deux.

Vous pouvez utiliser OTR pour chiffrer de bout en bout vos discussions instantanées. L'interface en console Primitivus utilise la bibliothèque python potr tandis que Libervia s'appuie sur l'implémentation javascript otr.js. Ainsi, vos discussions chiffrées sur Libervia sont vraiment sécurisées puisque le chiffrement est effectuée directement par votre navigateur ; il faut par contre prévoir des ralentissements, surtout au lancement d'OTR.

Autres nouveautés

On notera :

  • l'ajout des marque-pages de salons de discussion ;
  • l'affichage des états dans les salons de discussion ;
  • une meilleure intégration des commandes ad-hoc, permettant par exemple d'administrer le serveur depuis Primitivus ou Libervia;
  • la possibilité de supprimer tous ses messages, modifier son mot de passe ou supprimer son compte depuis Libervia ;
  • des menus contextuels sur les contacts et fenêtres de discussion ;
  • quelques nouveautés concernant les pages de blogs statiques.

Ré-usinage

Il est important, pour un projet comme SàT (multi-interfaces), de veiller à remanier le code lorsqu'on lui trouve des défauts de conception ou bien qu'on imagine un nouveau mécanisme. Ont subi entre autre un ré-usinage pour davantage de souplesse ou de généricité :

  • la découverte de services XMPP ;
  • l'envoi et la réception de messages ;
  • la gestion des commandes textuelles ;
  • la gestion de la liste de contact ;
  • l'organisation hiérarchique des constantes ;
  • les raccourcis clavier de Primitivus ;
  • l'arborescence des fichiers source de Libervia.

Ces modifications n’intéressent pas directement l'utilisateur mais elles nous facilitent la vie, et peut-être celles des personnes qui souhaiteraient plus tard nous filer un coup de main ! Il s'agit aussi de premiers pas pour amorcer le développement de l'interface pour téléphones portables et de nouvelles fonctionnalités.

Par ailleurs, nous misons toujours davantage sur XMLUI, le micro-format interne de description d'interface utilisateur que nous utilisons pour commander les frontaux depuis le backend. Désormais, les actions de l'utilisateur sont mieux intégrées et nous comptons améliorer le système, toujours davantage à chaque version.

Mais encore…

Le backend est maintenant distribué en tant que plugin pour Twisted et se lance par défaut en mode démon, tout comme Libervia. La séquence d'initialisation backend / frontaux a été améliorée, ceci corrige les problèmes qui pouvaient survenir lorsque SàT et Libervia étaient lancés depuis un script à peu d'intervalle. De plus, nous avons rajouté un fichier .service pour D-Bus, ce qui permet de lancer automatiquement le backend lorsqu'un frontal en a besoin.

Les chemins par défaut des fichiers utilisateurs respectent désormais les recommandations XDG : fichier de configuration dans ~/.config/sat, base de donnée et le reste dans ~/.local/share/sat. L'ancien fichier de configuration sera récupéré et éventuellement mis à jour.

Si l'adresse et le port du serveur XMPP sont laissés vides dans les paramètres de connexion, les bonnes valeurs peuvent être récupérées depuis un enregistrement DNS SRV qui correspond à la partie « domaine » du JID.

Un nouveau système de log fait son apparition, il est pleinement configurable et gère les couleurs, le formatage, le filtrage et le type de sortie (fichiers, mémoire…).

Aspect administratif

Nous avons déposé en préfecture les papiers pour la création de l'association « Salut à Toi »… cela a été accepté du premier coup, ce qui nous a agréablement surpris car le mode de fonctionnement de l'association est un peu particulier : direction collégiale, pas de président / secrétaire / trésorier mais deux co-administrateurs. Pour rappel, derrière ce projet il y a une volonté d'implication qui est incompatible avec l’exercice d'une autre activité professionnelle. Cela se traduit, pour les développeurs, par la nécessité de trouver une source de financement. Nous allons donc commencer à tester / adapter notre idée de modèle économique et ceci, bien entendu, dans le respect des engagements éthiques et moraux qui sont définis par notre contrat social.

Les adhésions à l'association sont notre source de financement privilégié ! Nous avons défini dans le règlement intérieur plusieurs montants de cotisation annuelle entre 10 et 100 euros, libre à chacun de choisir ce qu'il veut. Pour les personnes qui souhaiteraient nous soutenir sans pouvoir ou vouloir verser de contribution financière, c'est aussi possible : l'adhésion sans cotisation est prévue par le règlement intérieur. Comme ça, plus d'excuse ;-)

Il va par contre falloir attendre encore un peu avant que tout cela soit faisable par Internet. Nous allons ouvrir un compte en banque pour l'association et il faudra ensuite préparer un formulaire en ligne pour gérer les adhésions.

Rencontres

Nous étions présents cette année aux Journées du Logiciel Libre à Lyon, Pas Sage en Seine à Paris et aux Rencontres Mondiales du Logiciel Libre à Montpellier (voir les liens pour les vidéos des conférences). Nous avons pu rencontrer ou revoir quelques personnes grâce aux stands, et aux conférences de Goffi. Merci aux organisateurs de ces événements ainsi qu'à Reflets, qui a écrit un article sur SàT suite à la sortie de la dernière version, ce qui a permis de faire connaitre le projet à un plus large public.

Nous allons participer mercredi et jeudi prochain au « XMPP Summit » et à son hackaton qui se déroulent à Berlin. Serons notamment présents deux autres développeurs XMPP avec qui nous sommes en contact, dont Edhelas de Movim, et ensemble nous espérons pouvoir peser davantage pour faire standardiser de nouvelles extensions (notamment autour de Publish-Subscribe et pour le blogage) et encourager leurs implémentations.

Le samedi 27 septembre entre 14h et 17h30, Goffi participera à une émission de la radio « Ici et maintenant » enregistrée à Paris sur le thème de l'auto-hébergement. Il y a aura plusieurs autres invités dont deux développeurs de Jappix.

Nous souhaitons aussi organiser des rencontres au travers de l'association, au moins une fois par an sous forme d'assemblée générale ordinaire, et peut-être davantage. Le lieu et la date n'ont pas encore été discutés.

À noter aussi la création récente d'une liste de diffusion « users » pour les utilisateurs de SàT, qui vient compléter le salon de discussion et la liste de diffusion « dev ».

Et après ?

Nous souhaitons transférer nos propres blogs sur SàT. La version 0.6 se concentrera donc sur la fonctionnalité de blog (qui dans SàT est basée sur un système de permissions fines pour n'écrire qu'aux personnes de votre choix), le stockage d'images et l'implémentation des tags. Il s'agit de fonctionnalités essentielles et peut-être des derniers grands travaux avant la publication de la première version grand public, qui a pris un peu de retard et devrait être estampillée 0.7 ou 0.8.

Télécharger ce contenu au format Epub

Lire les commentaires

AFUP Lyon - 16 septembre 2014 : conférence sur Composer et la gestion des dépendances

9 septembre, 2014 - 00:36

L'antenne lyonnaise de l'AFUP (Association Française des Utilisateurs de PHP) organise le 16 septembre prochain une conférence sur Composer et la gestion de dépendances. Composer est un outil en PHP permettant de gérer les dépendances de son projet.

Lors de cette conférence, Jérémy Jourdin (de M6Web) nous parlera de Composer (l'outil de gestion de dépendances), Packagist (le dépôt sur lequel est branché par défaut Composer), Satis (un outil pour facilement installer un dépôt en local), Toran proxy (un outil pour mettre en cache les différents appels à composer).

La conférence aura lieu dans le grand amphithéâtre d’Epitech Lyon, au 86 boulevard Marius Vivier-Merle 69003 Lyon, à 19h00 le mardi 16 septembre 2014.

Les inscriptions à cette conférence gratuite se font sur cette page.

Télécharger ce contenu au format Epub

Lire les commentaires

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

9 septembre, 2014 - 00:35

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

[atlantico] Docteurs follamour? Ce que à quoi pourrait aboutir les biologistes qui piratent l’ADN

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

Les médias s'intéressent depuis peu au mouvement du biohacking, qui consiste à mettre le maximum de moyen en oeuvre pour démocratiser les technologies qui sont le plus souvent bloquées et réservées à une élite. Ce faisant, le mouvement permet à toute une communauté de penser de nouvelles façons d'utiliser des technologies pour des résultats parfois plus pratiques.

Lien vers l'article original: http://www.atlantico.fr/decryptage/docteurs-follamour-que-quoi-pourrait-aboutir-biologistes-qui-piratent-adn-thomas-landrain-1738646.html

Et aussi:

[Next INpact] Projet de loi numérique: le CNNum présente les thèmes de sa concertation

Par Xavier Berne, le vendredi 5 septembre 2014. Extrait:

Alors que le gouvernement a promis mercredi que le projet de loi relatif au numérique porté par Axelle Lemaire serait présenté l’année prochaine devant le Parlement, la grande concertation préalable à l’élaboration de ce texte approche à grands pas. Le Conseil national du numérique vient ainsi de dévoiler les premiers grands thèmes de cette consultation nationale, ainsi que quelques précisions concernant cette opération qui devrait débuter avant la fin du mois.

Lien vers l'article original: http://www.nextinpact.com/news/89709-projet-loi-numerique-cnnum-presente-themes-sa-concertation.htm

Et aussi:

[Rue89] Surprise! La France dans le top 5 mondial des e-gouvernements

Par Robin Prudent, le mercredi 3 septembre 2014. Extrait:

La France s’est aussi engagée […] à accroître l’utilisation de logiciels open source [libres, ndlr]. La nouvelle politique, introduite en 2012, a pour objectif de réduire les dépenses en technologies de l’information et de la communication (TIC) et améliorer leurs souplesses tout en encourageant l’innovation et l’engagement d’autres acteurs, comme les services locaux et les communautés de développeurs.

Lien vers l'article original: http://rue89.nouvelobs.com/2014/09/03/suprise-france-top-5-mondial-e-gouvernements-254613

Et aussi:

[Rue89] Firefox OS veut bousculer Android et iOS? C’est tout ce qu’on souhaite

Par Philippe Vion-Dury, le mardi 2 septembre 2014. Extrait:

Le navigateur Firefox sort en 2004, et détonne: libre, gratuit, collaboratif, issu d’un travail bénévole, il convainc tout de suite. Il a surtout su faire ce que Linux n’a pas réussi (dans l’univers des systèmes d’exploitation): dépasser les cercles de développeurs et de geeks pour toucher le grand public.

Lien vers l'article original: http://rue89.nouvelobs.com/2014/09/02/firefox-os-veut-bousculer-android-ios-cest-tout-quon-souhaite-254578

[ToulÉco] La mairie de Toulouse économise 1 million d'euros en passant au logiciel libre

Par la rédaction, le mardi 2 septembre 2014. Extrait:

Amorcé sous la précédente majorité, le basculement des services municipaux toulousains vers la suite bureautique LibreOffice a été confirmé par la nouvelle majorité. Il devrait même être achevé d’ici six mois. Résultat: le recours à ce logiciel libre va permettre une économie substantielle de 1 million d’euros pour la collectivité.

Lien vers l'article original: http://www.touleco.fr/La-mairie-de-Toulouse-economise-1-million-d-euros-en-passant-au,14366

[Libération.fr] Les cryptoparties, sans laisser d’adresse

Par Emmanuelle Chaze, le dimanche 31 août 2014. Extrait:

A Berlin comme à Paris, des rencontres entre citoyens sont organisées dans le but d’enseigner aux internautes à protéger leurs données sur la Toile.

Lien vers l'article original: http://ecrans.liberation.fr/ecrans/2014/08/31/les-cryptoparties-sans-laisser-d-adresse_1090893

Et aussi:

Télécharger ce contenu au format Epub

Lire les commentaires

Lancement de la campagne de financement de la caméra libre AXIOM Beta 4K

8 septembre, 2014 - 23:11

L'attente est terminée! La campagne de financement de la caméra libre AXIOM bêta 4K sera lancée dans une trentaine d'heures (NdM: est lancée). Destinée dans un premier temps aux hackers et aux développeurs, elle sera vendue à prix coûtant. Plus d'informations sont à venir (avec des traductions dans la langue de Molière)

Partagez l'information et contribuez à la libération de la technologie du cinéma numérique, via apertus.org.

    Une heure avant l'ouverture de la campagne (mercredi 10 septembre à 9h, heure de Paris), un rendez-vous sur IRC a été prévu pour en discuter, sur le canal #apertus du réseau irc.freenode.org (accès web). Cela sera notamment l'occasion d'évoquer l'histoire du développement du projet.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Compte-rendu de la rencontre KDE à Randa

    8 septembre, 2014 - 08:25

    La rencontre KDE à Randa (en Suisse) permet chaque année aux développeurs (et autres? il me semblait que ça parlait de designers) y participant de passer une semaine complète à travailler sur KDE (et à manger des chocolats aussi).

    Concernant la collecte de fonds, 428 personnes ont donné plus de 15 000 € (sur un objectif de 20 000), permettant à plusieurs dizaines de participants de se retrouver, du samedi 9 au vendredi 15 août, pour planifier et travailler sur le futur de KDE.

    Voici un récapitulatif non-exhaustif de l’évènement.

    Sommaire Son

    D’après un des participants, l’équipe multimédia a traité à peu près 220 bogues dans Phonon, KMix et Amarok !

    KMix gère désormais les écrans à haute densité de pixels (modification avec capture d’écran), la sélection du canal principal (master) se fait désormais par une liste et non par des boutons radio (modification avec capture d’écran avant/après) conformément aux HIG (recommandations pour la conception d’interfaces graphiques) de KDE.

    D’autres corrections mineures ont été effectuées : par exemple, le dialogue de configuration était devenu ridiculement grand (sic) à cause d’un (large) message d’avertissement (pourtant la plupart du temps caché).

    KMix a été en partie porté vers KF5, toutes les fonctionnalités de base sont disponibles : fenêtre principale, zone de notification, raccourcis de contrôle du volume, menu de son, sauvegarde et restauration du volume. De plus, un dialogue de configuration de son basé sur PulseAudio et QtQuick 5 a été créé.

    Enfin, la bêta de Phonon 4.8 est sortie : son dorsal (backend) Gstreamer a été porté vers Gstreamer 1 et la fiabilité de la bibliothèque a été améliorée.

    Éducation Autres applications

    Gwenview a été porté vers KF5 et il reste de nombreux avertissements à corriger là où les bibliothèques de transition KDElibs4Support sont encore utilisées.

    Concernant KDevelop, la prise en charge de QML, travail issu d’un GSoC, a été porté par l’étudiant lui-même sur KDevelop 5 (version de KDevelopp portée sur KF5), et l’équipe KDE On Windows s’est assurée que KDevelop 5 fonctionnait parfaitement sur Windows.

    De nombreux bogues ont été corrigés dans Kdenlive, et le travail de réusinage qui avait été entamé en 2012 (en particulier 2 mois de travail après une campagne Indiegogo réussie) a bien avancé — mais c’est une énorme tâche, très importante, qui sera bénéfique sur le long terme.
    Un diagramme a été fait pour montrer aux nouveaux développeurs la nouvelle architecture de Kdenlive. La branche master reçoit les corrections de bogues, la branche next est la branche du réusinage. Les classes (il y en a plusieurs qui font entre 1 000 et 7 000 lignes) sont divisées en classes plus petites, et le code est modifié petit à petit pour correspondre à l’architecture du diagramme.

    KMyMoney a également été porté vers KF5 : ayant plus de 1 000 avertissements au départ (concernant des classes obsolètes pour la plupart), il n’y en a plus que 44. KMyMoney utilise encore quelques classes de KDElibs4Support en attendant que QCalendarSystem, qui remplace KCalendarSystem, soit disponible (prévu pour Qt 5.4), les modules doivent également être portés. Le travail sur la version Windows a bien avancé et devrait sortir en même temps que les autres.

    Inqlude

    Première alpha (0.7) de l’outil Inqlude, qui permet de créer le site du même nom, et qui peut créer et vérifier des manifestes au format d’Inqlude. Il n’est pas encore possible de télécharger des paquets de bibliothèques, il existe une implémentation basique mais pas les métadonnées nécessaires.

    La prochaine alpha (0.8) sera principalement marquée par l’ajout de documentation sur comment contribuer. La 0.9 marquera la stabilité du format des fichiers manifestes. La 1.0 pourra gérer les paquets locaux.

    Livre sur KF5 et api.kde.org

    Le KF5 book est un livre pour les développeurs C++/Qt pour concevoir des applications basées sur KF5. Le livre se base sur beaucoup de contenus déjà existants et est original dans le fait de regrouper tout cela, et d’introduire des tutoriels et des exemples pratiques.

    Techniquement, chaque partie du livre est ou sera maintenue dans le dépôt git du cadriciel correspondant grâce au système de sous-module git, il est écrit en Markdown (syntaxe utilisée sur Linuxfr pour la mise en forme de tous les contenus) et Pandoc est ensuite utilisé pour le convertir dans le format qu’on souhaite (PDF, e-book, etc).

    Grâce à cette mécanique bien huilée, chaque modification était rapidement propagée, et les itérations (ajouts ou corrections) ont pu aller très très vite. Ajoutons à cela la proximité physique de tous les participants, cela a été extrêmement productif!

    Enfin, api.kde.org a été amélioré. La page d’accueil n’a pas encore changée, mais chaque cadriciel dispose maintenant d’une boite d’information (qui est le mainteneur, comment l’utiliser avec CMake ou QMake — en effet, les cadriciels KDE peuvent être utilisés dans des projets QMake —, la liste de discussion et le salon de discussion, une URL pour cloner le projet avec git, et un lien vers sa page Inqlude (cf. section ci-dessus).

    Autres événements

    Un autre évènement important, pour la communauté KDE, est la seconde édition de LaKademy (Akademy en Amérique latine), du 27 au 30 août.

    Et bien sûr, il y a l’Akademy 2014, avec des tas de conférences géniales du 6 au 12 septembre à l’université de Brno en République Tchèque.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Hardened BSD, le à-la-grsecurity dans FreeBSD

    7 septembre, 2014 - 21:23

    Shawn Webb et Oliver Pinter, tous deux à l'origine du projet HardenedBSD, l'ont rendu officiel fin août. Il s'agit d'un projet au sein de FreeBSD, et pas d'une extension de la famille des BSD (FreeBSD, NetBSD, OpenBSD, DragonFly BSD, et leurs dérivés comme GhostBSD ou PC-BSD).

    Le but premier de Hardened BSD est d'apporter le support ASLR, Address Space Layout Randomization ou distribution aléatoire de l'espace d'adressage, qui existe chez tous les autres BSD, DragonFly BSD compris, dans la branche courante et aussi rétroporter le tout pour les versions précédentes.

    Aussi, inspiré de PaX (correctif sécurité du noyau Linux, voir aussi W^X chez OpenBSD), il propose le support Segvguard afin de surveiller les segmentation faults et se protéger contre les attaques par ce biais.

    Enfin dans une sous-branche, il renforce les contrôles des appels ptrace (ce dont votre serviteur s'occupe ;-)).

    Télécharger ce contenu au format Epub

    Lire les commentaires

    OCaml 4.02

    7 septembre, 2014 - 00:03

    La version 4.02 du langage OCaml a été annoncée vendredi 29 août. Elle fait suite à la version 4.01 publiée en septembre 2013. Il s'agit de l'implémentation la plus vivace du langage ML (Meta language) et l'un des langages fonctionnels les plus utilisés (comme Haskell, XSL, Lisp…)

    Sommaire

    Ce changement mineur de version n'est pas représentatif des évolutions présentes. Cette version inclut des changements dans la syntaxe du langage et des outils, pouvant casser la compatibilité avec les programmes existants.

    Les changements d'outils et de bibliothèque Points d'extensions et séparation de Camlp4

    L'une des évolutions les plus attendues modifie le paradigme de méta-programmation d'OCaml en introduisant une étape de compilation permettant de transformer l'arbre syntaxique du programme, un mécanisme analogue¹ aux macros Lisps.

    ¹ Mais seulement analogue !

    Le paradigme de méta-programmation précédent s'appuyait sur l'historique pré-processeur camlp4 qui permettait de définir des dialectes d'OCaml en enrichissant sa syntaxe. Les applications principales de ce type de pré-processeur sont :

    • La représentation de données externes dans le système de types du programme ce qui permet de garantir à la compilation que l'ensemble des types sont cohérents entre eux. La bibliothèque PG'OCaml permet ainsi de vérifier que la cohérence de type des requêtes SQL avec le code OCaml à la compilation.

    • La génération automatique de fonctions de sérialisation et déserialisation de structures de données, ce qu'implémente la sexplib.

    • La création de sous-langages propres à un langage dédié, ceci est utilisé par le serveur web OCsigen de sorte qu'un document HTML généré par un programme OCaml/OCsigen valide est valide.

    Les principaux défauts de camlp4 sont sa complexité et l'augmentation du temps de compilation que son utilisation implique : un programme traité par camlp4 passe une fois dans l'analyseur syntaxique de camlp4 puis le texte correspondant passe dans l'analyseur syntaxique du compilateur ocaml. De plus, camlp4 faisant partie de la distribution d'ocaml les mises à jour ne pouvaient se faire que de pair avec celles du compilateur. Ce type de dépendance ralentit la correction et cause des bogues et des incompatibilités, parfois subtiles, avec la syntaxe d'OCaml. Si le dernier point devrait s'améliorer grâce à la séparation de ocamlp4 du compilateur, les autres restent d'actualité.

    Le nouveau paradigme de méta-programmation faisant son arrivée dans OCaml est les points d'extensions, qui sont des éléments syntaxiques dont la forme est définie par le langage mais dont la sémantique est définie par un pré-processeur.

    Souvenons-nous que lors de la compilation d'un programme, les instructions sont transformées dans un arbre syntaxique abstrait que le compilateur traduit en code machine — après d'éventuelles optimisations. Comme le langage OCaml se compile lui-même, la structure de cet arbre est une structure de donnée OCaml. Il est maintenant possible de modifier la structure de cet arbre à travers les fameux points d'extensions. L'intérêt premier est de travailler sur un objet déjà traité et construit par le compilateur, ce qui limite les erreurs et facilite l'écriture des extensions. On y gagne aussi en vitesse d'exécution puisque l'étape d'extension se fait dans le processus de compilation, et non pas via un appel externe. Enfin, puisque les points d'extensions ne modifient pas la syntaxe d'OCaml, faire cohabiter différentes extensions devrait être plus facile.

    Aujourd'hui camlp4 est encore très largement utilisé. Le sortir du cœur d'OCaml ne va pas le faire disparaître immédiatement, car de nombreux modules n'ont pas encore leur équivalent via les points d'extensions. On peut toutefois maintenant supposer qu'il va mourir de sa belle mort, après avoir été utilisé pendant de nombreuses années et avoir été une figure majeure de l'univers OCaml. Le projet est désormais hébergé sur github, ce qui marque sa séparation d'avec le cœur d'OCaml.

    (Par contre les amateurs de Lisp seront déçus : cet accès au code est limité au temps de la compilation, et le programme compilé n'a pas la possibilité de se modifier lui-même. Cela n'est possible qu'à travers un programme tiers.)

    Séparation de Labltk

    La bibliothèque Labltk était jusqu'à présent une partie intégrante de la distribution OCaml. Elle sera désormais disponible comme une bibliothèque tierce.

    Nouvelles extensions au langage Exceptions et filtrage par motif

    La gestion des exceptions est très performante en OCaml. En compilant le programme avec les bonnes options, une exception est transformée en une simple instruction de saut, et est souvent utilisée pour sortir d'un traitement (boucle, etc). Cet usage des exceptions est maintenant mieux intégré dans le langage puisqu'une exception peut être traitée comme une valeur de retour et être intégrée dans un filtrage par motif.

    En effet, l'utilisation d'exceptions dans du code récursif pouvait poser problème. Voici un petit exemple qui illustre la situation : le programme suivant permet de lire un fichier ligne par ligne et stocker l'ensemble des lignes dans une liste :

    let read_lines inc = let rec loop acc = (* Schéma classique de récursion terminale à travers un accumulateur *) try let l = input_line inc in loop (l :: acc) (* Appel récursif en ajoutant la ligne lue à l'accumulateur *) with End_of_file -> List.rev acc (* Renvoie la liste accumulée quand on atteint la fin du fichier *) in loop []

    Sauf que l'appel à la fonction loop est présent dans un gestionnaire d'exception, ce qui empêche la fonction d'être optimisée en récursion terminale. Sur un fichier de taille suffisamment importante, le programme va saturer la pile. Il est désormais possible d'utiliser la syntaxe suivante, qui considère que l'exception est une valeur de retour possible de la fonction :

    let read_lines inc = let rec loop acc = match input_line inc with | l -> loop (l :: acc) (* Appel récursif en ajoutant la ligne lue à l'accumulateur *) | exception End_of_file -> List.rev acc (* Renvoie la liste accumulée quand on atteint la fin du fichier *) in loop []

    Dans cette nouvelle syntaxe, l'exception est devenue un type de retour de la fonction qu'il est possible d'intégrer dans le filtrage par motif. De cette manière, il n'est plus nécessaire de mettre en place un bloc try … with et la fonction peut maintenant être optimisée par le compilateur. Cette nouvelle approche a, de plus, l'avantage d'être plus lisible et beaucoup plus concise.

    Modifications du système de module

    Les langages de la famille ML ont un riche système de modules qui se distingue notamment par sa notion de foncteur.
    Un module est une sorte de paquetage contenant des définitions de type, parfois totalement abstraites, et les fonctions agissant sur ces types qui vont avec.
    Autrement appelés modules paramétrés, les foncteurs sont aux modules ce que les fonctions sont aux valeurs. Tout comme une fonction construit une nouvelle valeur à partir de valeurs paramètres, un module paramétré permet de construire un nouveau module à partir de modules déjà construits. On peut faire une analogie avec la généricité dans le monde objet.
    Cependant, cette richesse peut entraîner des comportements non-intuitifs pour l'utilisateur. Cette nouvelle version du compilateur corrige trois problèmes fréquemment rencontrés avec le système de modules.

    Alias de module

    Notamment, dans les versions antérieures d'OCaml, la pratique courante de définir un alias court pour un module

    module S = Module_with_a_very_long_name

    avait pour effet de créer une nouvelle copie du module Module_with_a_very_long_name. Cette copie inutile augmentait parfois fortement la taille des exécutables générés. Dans cette nouvelle mouture du compilateur, le module S est défini comme un simple alias évitant cette copie potentiellement coûteuse.

    Foncteur génératif

    Un autre exemple de comportement non-intuitif apparaissait lors de l'utilisation de foncteur pour générer des modules uniques. Imaginons par exemple que nous souhaitons générer plusieurs types uniques d'identifiants avec un foncteur de la forme :

    module MakeId (M : sig end ) : sig type t ... end = struct type t = int ... end

    On peut alors construire des nouveaux modules d'identifiants avec :

    module Id1 = MakeId(struct end) module Id2 = MakeId(struct end)

    Les deux types Id1.t et Id2.t sont alors distincts et l'on ne peut pas mélanger les deux types d'identifiants. Cependant écrire à chaque fois un module vide est relativement pénible. Une idée serait d'écrire plutôt :

    module E = struct end module Id1 = MakeId(E) module Id2 = MakeId(E)

    Malheureusement, avec cette définition les deux modules générés sont identiques car générés à partir du même module E.

    La nouvelle extension sur les foncteurs génératifs simplifie ce cas particulier où le foncteur prend le module "vide" en argument. Avec cette extension on peut écrire plus simplement :

    module MakeId () : sig type t ... end = struct type t = int ... end module Id1 = MakeId() module Id2 = MakeId()

    et obtenir deux types distincts Id1.t et Id2.t.

    Ouverture locale de modules

    Afin de faciliter l'utilisation des modules, OCaml, depuis la version 3.12, dispose de plusieurs constructions syntaxiques pour ouvrir localement un module, i.e. importer les identifiants du module dans l'espace de noms courant.

    Par exemple, pour utiliser l'opérateur + pour additionner des float, il est possible
    de définir un module :

    module Float = struct let ( + ) = ( +. ) end

    Ouvrir ce module globalement aurait l'inconvénient de masquer l'addition des entiers, mais on peut l'ouvrir localement

    let x = let open Float in 1. + 5. let y = Float.( 1. + 5. )

    Dans la définition de y, le module Float est ouvert uniquement à l'intérieur des parenthèses. Cette construction s'est révélée très appréciée et vient d'être étendue pour éviter certains doublons de parenthèses

    let list_f = Float.[ 1. + 2.; 3. ] (* plutôt que Float.( [ 1. + 2.; 3. ] ) *) let array_f = Float.[| 1. + 2. ; 3. |] (* plutôt que Float.( [| 1. + 2.; 3. |] ) *) type record_t = { content : float} let record = Float.{content = 1. + 2. } (* plutôt que Float.({content = 1. + 2. }) *) Types ouverts

    Le système de type d'OCaml s'enrichit d'une nouvelle catégorie de type, les types ouverts qui sont à mi-chemin entre les types sommes classiques et les variants polymorphes.

    Petit rappel sur les types enumérés existants Types sommes

    Dans les types sommes, l'ensemble des constructeurs est déterminé lors de la définition du type

    type card = King | Queen | Jack | As | Suit of int

    Comme le type est figé, il est facile de vérifier dans un filtrage par motif que tous les cas possibles sont gérés. Par contre une fois cette définition posée, les constructeurs du type card sont fixés et rien ne peut les changer. Si on souhaitait définir le type tarot_card à partir du type card, on serait limité à :

    type tarot_card = Card of card | Knight

    ce qui alourdit les notations. Par exemple, étendre la fonction

    let is_jack card = match card with | Jack -> true | _ -> false

    au type tarot_card nécessite de définir une nouvelle fonction

    let is_jack_tarot tarot_card = match tarot_card with | Card card -> is_jack card | _ -> false

    cette expression utilise l'underscore qui, en OCaml, signifie en quelque sorte le joker, ou en d'autres termes "pour tous les autres cas, fais ceci"

    Variants polymorphes

    Les variants polymorphes permettent de s'abstraire de cette limitation et d'utiliser des constructeurs directement sans avoir à les définir au préalable. Par exemple :

    let seven = `Suit 7

    définit une nouvelle variable à partir du constructeur `Suit. Contrairement aux apparences, le constructeur `Suit n'a rien à voir avec le constructeur Suit définit pour le type card. Le ` dénote le constructeur d'un variant polymorphe : n'importe quel nom commençant par une majuscule et précédé par ` est un constructeur de variant polymorphe classique. Pour l'instant le compilateur sait juste que le constructeur `Suit fait partie d'un ensemble ouvert qui n'est pas encore complètement défini.

    Comme pour les types sommes, on peut utiliser le filtrage de motif pour définir des fonctions sur ces variants, par exemple :

    let is_jack card = match card with | `Jack -> true | _ -> false

    Avec cette définition, l'application is_jack seven est bien typée et retourne false comme attendu. Cependant, la fonction is_jack peut être appliquée à (presque) n'importe quel variant polymorphe : is_jack (`John `Do) est aussi bien typé et retourne false.

    Le compilateur utilise un système de type relativement complexe pour vérifier que les expressions impliquant les variants polymorphes sont valides. Par exemple, appliquer la fonction :

    let value_figure tarot_card = match tarot_card with | `King -> 4.5 | `Queen -> 3.5 | `Knight -> 2.5 |` Jack -> 1.5

    à seven déclenchera une erreur de type durant la compilation car la fonction value_figure ne sait que faire du constructeur `Suit. Cependant, à cause de la flexibilité des variants polymorphes, certaines erreurs ne peuvent pas être détectées par le compilateur. Par exemple :

    let is_suit card = match card with | `Suit -> true | _ -> false

    est une fonction OCaml valide, néanmoins is_suit seven déclenche une erreur de type parce que dans la fonction is_suit, le constructeur `Suit n'admet pas d'argument. La bonne version de cette fonction serait :

    let is_suit card = match card with | `Suit _ -> true | _ -> false

    mais le compilateur n'a aucun moyen de le deviner.

    L'apport des types ouverts

    Les types ouverts sont, eux, des types sommes auquels on peut ajouter de nouveaux constructeurs après leur définition. Par exemple, on peut commencer par créer un type ouvert sans constructeur :

    type open_card = ..

    Puis, on peut rajouter les constructeurs de card dans un premier temps

    type open_card += King | Queen | Jack | As | Suit of int

    À partir de ce point, on peut réaliser une copie de ce type ouvert

    type open_tarot_card = open_card = ..

    et étendre cette copie

    type open_tarot_card += Knight

    La fonction

    let is_jack card = match card with | Jack -> true | _ -> false

    est alors de type open_card -> bool mais accepte en entrée tout type qui est une extension du type open_card: is_jack Knight est valide et renvoie false comme attendu.

    Un point important dans la fonction précédente est la présence dans le filtrage de motif du motif _ : le type open_card étant ouvert, si on veut être exhaustif, il est nécessaire d'offrir une alternative pour les constructeurs qui ne sont pas encore connus. En cas d'oubli, le compilateur émet un avertissement pour signaler que le filtrage n'est pas exhaustif en présence d'extension.

    Une différence majeure avec les variants polymorphes est que tous les constructeurs de open_card sont connus par le compilateur, qui peut donc plus facilement détecter certaines erreurs.

    La fonction

    let is_suit card = match card with | Suit -> true | _ -> false

    déclenche donc bien une erreur de compilation à cause du mauvais usage du constructeur Suit contrairement au cas des variants polymorphes.

    Un détail amusant est qu'il existait déjà une forme de type ouvert dans les versions antérieures d' OCaml : le type exn des exceptions qu'il était possible d'étendre en déclarant une nouvelle exception

    exception Open

    Avec l'apparition des types ouverts dans la version principale du compilateur, le type des exceptions est devenu un cas particulier de type ouvert.

    Rappel sur les types algébriques généralisés

    Introduits dans la version 4.0 il y a deux ans, les types algébriques généralisés (GADT) sont une évolution importante apportant plus d'expressivité au système de types.

    Ce type de données permet de structurer un type somme en spécifiant quelles opérations sont autorisées sur chacune des valeurs possibles. Le but est bien sûr de donner plus de sécurité au programme en vérifiant dès la compilation qu'une action peut s'appliquer pour une valeur donnée.

    Par exemple, un arbre bicolore oblige chaque nœud noir à avoir un parent rouge. Il est possible de vérifier cette règle en contrôlant à chaque opération d'insertion que l'ensemble de la cohérence de l'arbre est respectée. Toutefois, grâce aux GADT, ce contrôle peut être réalisé lors de la compilation du code : la cohérence de la structure de données sera ainsi garantie par le compilateur.

    Cela permet de :

    • se reposer sur le compilateur pour garantir la structure de données : une erreur dans l'implémentation sera détectée au plus tôt.
    • accélérer la vitesse d'exécution du code : puisque la structure est garantie par le compilateur, il n'est pas nécessaire de contrôler chaque opération à l'exécution.
    Avant les GADT

    Imaginons que nous nous intéressons à des expressions mélangeant des entiers, des booléens et les opérations usuelles sur ces types ; par exemple, (7 + 8) = 15 && false.

    Une manière de les représenter en OCaml avec un type somme est la suivante :

    type expre = | Eq of expre * expre | Nbr of int | Bool of bool | Plus of expre * expre | Minus of expre * expre | Or of expre * expre | And of expre * expre

    Le problème de cette représentation est que l'expression

    7 || (true + 4)

    représentée dans ce type par

    Or (Nbr 7, Plus (Bool true, Nbr 4))

    est bien typée, car elle respecte la définition du type. Du point de vue du compilateur, tout va bien, même si sémantiquement, cette expression est absurde.

    La résolution classique de cette ambigüité passe par une redéfinition un peu bavarde du type expre

    type expre = | BoolExpre of bool_expre | IntExpre of int_expre and bool_expre = | BoolValue of bool | BoolEq of bool_expre * bool_expre | IntEq of int_expre * int_expre | BoolOr of bool_expre * bool_expre | BoolAnd of bool_expre * bool_expre and int_expre = | IntValue of int | IntPlus of int_expre * int_expre | IntMinux of int_expre * int_expre

    Dans la pratique, on rencontre très fréquemment ce problème de typage dans la définition des types dérivés d'un type de base, par exemple un type “paramètre d'un programme” dont dérivent des types “callback lors de la mise à jour” ou “fonction de sérialisation du paramètre”: l'ajout d'un cas dans le type de base demande l'ajout d'un ou plusieurs cas dans les types dérivés.

    Avec les GADT

    Les GADT permettent de redéfinir les expressions précédentes de sorte que les expressions correctement typées soient également sémantiquement valides. Les règles de validités sémantique, autrement dit l'"invariant", que l'on souhaite garantir, est donc exposé au compilateur, qui garantit que cet invariant est respecté. Redéfinissons notre type avec les GADT :

    type _ expre = | Eq : ('a expre * 'a expre ) -> bool expre | Nbr : int -> int expre | Bool : bool -> bool expre | Plus : (int expre * int expre) -> int expre | Minus : (int expre * int expre) -> int expre | Or : (bool expre * bool expre) -> bool expre | And : (bool expre * bool expre) -> bool expre

    Si on compare cette définition à celle d'un type somme classique, une première différence saute aux yeux : les constructeurs (Eq, Nbr, …) sont explicitement typés. Typer explicitement les constructeurs permet d'exprimer les relations de dépendances entre les constructeurs, le type de leurs arguments et le type résultant. Par exemple, le constructeur Eq : 'a expre * 'a expre -> bool expre construit une expression booléenne à partir de deux expressions de même type : la sémantique de l'égalité est encodée directement dans le système de type. Le compilateur peut donc rejetter l'expression sémantiquement invalide

    # Or (Nbr 7, Plus (Bool true, Nbr 4));; Error: (Nbr 7) has type int expre but an expression was expected of type bool expre Type int is not compatible with type bool

    On peut aussi utiliser ce type algébrique généralisé pour définir une fonction d'évaluation de ces expressions

    let rec eval : type etype. etype expre -> etype = function | Nbr n -> n | Bool b -> b | Eq (left, right) -> (eval left) = (eval right) | Plus (left, right) -> (eval left) + (eval right) | Minus (left, right) -> (eval left) - (eval right) | Or (left, right) -> (eval left) || (eval right) | And (left, right) -> (eval left) && (eval right)

    Plusieurs choses intéressantes se voient dans cette fonction d'évaluation. Premièrement, le type de la fonction est défini explicitement, avec notamment la déclaration du type etype, que l'on "invente" pour l'occasion. Deuxièmement, le type de retour correspond au paramètre de type dans l'expression : il s'agit d'une fonction polymorphe, car la fonction renvoi le type "inventé". Mais si on regarde le type etype à l'intérieur du filtrage du motif, on se rend compte que ce type varie en fonction de la branche dans laquelle on se trouve. À l'intérieur de la branche Nbr n , etype est un entier etype=int tandis que dans la branche Eq (left, right), expr est de type etype=bool alors que left et right sont de type 'a expre. Les constructeurs des GADT imposent donc des contraintes de types différentes pour chaque branche. Cela permet d'exprimer des fonctions qui ont un comportement et un type différent pour chacun des constructeurs du GADT.

    On voit dans cet exemple que grâce aux GADT, la définition d'une fonction d'évaluation ne requiert pas l'introduction d'un type nouveau : on peut décrire la fonction d'évaluation et donc en particulier son type directement à partir du type de base. Avec l'ancienne définition du type expre, nous aurions du introduire un nouveau type somme décrivant le résultat d'une évaluation, et de surcroît, nous n'aurions pas pu représenter le fait que la fonction d'évaluation transforme une expression booléenne (resp. numérique) en valeur booléenne (resp. numérique) dans le système de types.

    Changements dans les bibliothèques standard Chaînes de caractères immutables

    En OCaml les chaînes de caractères de type string ont été historiquement conçues comme mutables. Cependant, au fil des années, le consensus a évolué pour considérer qu'il était généralement préférable d'utiliser ce type comme s'il était immutable. Cette différence entre la pratique et le système de type était une bizarrerie pour un langage fonctionnel qui se targue de l'expressivité de son système de types. Il a donc été décidé de séparer le type string et le module attenant String en deux : d'un côté les chaînes de caractères immutables String, d'un autre les tampons mutables Bytes. Néanmoins, une séparation brutale aurait cassé un trop grand nombre de bibliothèques tierces. Pour adoucir cette séparation, le compilateur considère par défaut que les modules Bytes et String et les types associés sont identiques. Pour activer la distinction entre ces modules, il est nécessaire de passer l'option -safe-string au compilateur durant la compilation.

    Usages des GADT dans la bibliothèque standard

    Les types algébriques généralisés étant un ajout récent dans le compilateur, ils ne sont pas encore très utilisés dans la bibliothèque standard d'OCaml. Cependant, dans cette nouvelle version, les GADT apparaissent dans deux composants importants d'OCaml : le module Printf et la bibliothèque Bigarray.

    La bibliothèque Bigarray

    La distribution standard du compilateur OCaml inclut une bibliothèque de manipulation des tableaux multidimensionnels nommée Bigarray. Conçue pour s'interfacer facilement avec le C et le Fortran, elle est basée sur un type relativement complexe : ('a, 'b, 'c) Genarray.t. Les trois paramètres de type correspondent à :

    • 'a : le type de la représentation OCaml des éléments
    • 'b : le type de la représentation en C des éléments
    • 'c : l'ordre des dimensions dans le tableau (i.e. layout fortran ou C)

    Laissons de côté pour l'instant le type 'c. Si on regarde les types 'a et 'b, il est clair que les deux sont interdépendants. Pour gérer cette interdépendance, la bibliothèque Bigarray introduisait un type abstrait ('a, 'b) kind qui représentait un couple valide de représentation OCaml et C. Les valeurs possibles de ce type étaient réalisées grâce à des variables opaques telles que :

    • float32 : (float, float32_elt) kind
    • int : (int, int_elt) kind

    Le problème avec ces variables opaques était qu'il est totalement impossible de les manipuler, ce qui posait problème dans certaines situations.

    Pour pallier ce problème, le type abstrait kind a été remplacé par un GADT de la forme :

    type (_,_) kind = | Float32 : (float, float32_elt) kind | Int : (int, int_elt) kind | ...

    L'avantage de cette construction est qu'elle permet d'exprimer les contraintes sur les types 'a et 'b directement dans la définition du type kind. De ce fait, il n'est plus nécessaire d'utiliser des variables opaques pour faire respecter l'interdépendance entre 'a et 'b. En utilisant les variables de type kind, il devient possible de définir une fonction renvoyant l'équivalent du zéro pour le type OCaml 'a

    let zero (type a) (type b) ( k : (a,b) kind) : a = match k with | Float32 -> 0. (* float *) | Int -> 0 (* int *) | ...

    L'utilisation des types algébriques généralisés permet donc d'avoir un comportement et un type spécifique pour chacune des branches du filtrage de motif. À partir de cette fonction zero, on peut ensuite écrire une fonction générique qui construit un tableau rempli de zéros

    let create_zero kind layout dims = let array = Genarray.create kind layout dims in (* uninitialized array *) Genarray.fill (zero kind); array

    Une autre utilisation possible serait de calculer la taille en bytes d'un tableau sans avoir à passer par les détails de l'implémentation.

    Réécriture de la bibliothèque Printf

    Qu'est-ce que le module Printf ? Il s'agit tout simplement du module associé à la fonction C éponyme, mais à la sauce OCaml : avec l'inférence de type. Cela signifie que l'instruction suivante ne compilera pas :

    # Printf.printf "Hello %d" "world";; Error: This expression has type string but an expression was expected of type int

    En effet, le paramètre world ne correspond pas au type %d attendu. Comment est-ce possible ? Jusqu'à présent grâce à une magie interne assez difficile à maintenir. Celle-ci a désormais été réécrite à l'aide de la syntaxe des GADT. Cela ne change pas grand-chose pour l'utilisateur (l'interface du module n'a pas changé), mais il s'agit d'une réécriture d'un module particulièrement compliqué, et un exemple de ce qu'il est possible de faire à travers les GADT.

    Que devient OCaml aujourd'hui ?

    La dernière dépêche remonte à maintenant deux ans, et était sortie pendant une transformation du langage : ces dernières années, OCaml est passé d'un langage universitaire, destiné à implémenter des algorithmes et enseigner l'informatique, à celui d'un langage professionnel qui se veut apte à répondre à des besoins actuels. Qu'en est-il aujourd'hui ?

    Nouveau wiki

    Un wiki est maintenant disponible à l'adresse suivante : http://ocaml.org/, le site se veut être la vitrine communautaire du langage.

    Opam

    Opam est le nouveau gestionnaire de paquets pour OCaml. À la manière de maven (pour java), ou pip (en python), il permet d'accéder à l'ensemble des bibliothèques disponibles à travers un seul outil. Il y a supplanté Godi qui n'avait pas la même visibilité. Signe des temps, opam a été développé par ocamlpro.

    Opam permet de maintenir plusieurs versions du langage sur un même poste, et de basculer d'une version à une autre. Créer un dépôt local est aussi relativement aisé et cela plus encore dans la future version 1.2 (actuellement en beta) qui permet d'installer un nouveau paquet à partir de n'importe quel dépôt git contenant les métadonnées requises.

    Accès au code via github

    La communauté s'est posée la question de savoir comment obtenir des retours de la part des contributeurs. La liste de diffusion est active, mais il s'agit d'un principe vieillissant, qui ne facilite pas les échanges de code. Le serveur hébergeant le code est le serveur de l'INRIA basé sur un svn.

    Il a été décidé expérimentalement d'ouvrir OCaml sur github pour voir si les retours seraient plus nombreux en terme de contributions (voir la discussion sur la liste de diffusion et l'annonce sur le blog de l'équipe Gallium).

    L'ensemble des branches de développement sont disponibles à travers opam, ce qui permet de basculer très facilement sur une version expérimentale pour tester les fonctionnalités à venir.

    Nombreuses bibliothèques pour la vraie vie

    Lorsqu'on regarde l'ensemble des bibliothèques disponibles pour OCaml, nombre d'entre elles servent à des problématiques vraiment pratiques, ne couvrant pas forcément que des sujets théoriques ; citons par exemple :

    Pour le réseau
    • Ocsigen, un framework pour écrire très rapidement des applications web (client et serveur) entièrement en OCaml
    • Js_of_ocaml est un compilateur développé par le projet ocsigen traduisant le bytecode OCaml en code javascript
    • Ocamlnet, la bibliothèque couteau suisse pour de nombreux protocoles réseau. Cette bibliothèque énorme a été utilisée en production chez MyLife.com. Elle compte, entre autres, nethttpd, un serveur web haute performance, très scalable.
    • Un binding SSL
    • Une implémentation de TLS
    • Une bibliothèque pour le SMTP
    • Un serveur WebSocket
    Bibliothèques côté clients Format de fichiers Autres projets intéressants

    On pourra trouver une liste assez exhaustive des bibliothèques disponibles sur caml.org

    Livres

    Quelques livres sont sortis depuis l'année dernière sur le langage. Ils n'ont pas été présentés sur le site au moment de leur parution, voici donc l'occasion de les présenter pour ceux qui veulent s'intéresser au langage :

    Real World OCaml, sorti en novembre 2013, présente le langage, mais se veut être un livre pratique pour répondre aux cas d'utilisation que l'on peut rencontrer au quotidien : comment écrire un parseur syntaxique, la construction d'une interface graphique à travers les mixins… Il a été écrit en partenariat avec les utilisateurs OCaml puisque tout le monde pouvait contribuer à sa rédaction, et est aujourd'hui entièrement disponible en ligne.

    OCaml from the Very Beginning permet de se plonger dans le langage en douceur. Il est destiné à un public ne connaissant pas le langage et souhaitant le découvrir.

    More OCaml : Algorithms, Methods & Diversions, tout récemment, complète le précédent et permet d'aller plus loin dans le langage.

    Remerciements

    L'écriture de cette dépêche n'aurait pas été possible sans la participation de tous. Merci à BAud, chimrod, Def, Jacques-Pascal Deplaix, jumbojet, Michaël, octachron, Ontologia, palm123, Snark et Tonton Th pour leur remarques et le temps passé à l'écriture.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    ULLM à la journée des Associations le 20 septembre 2014 à Martigues

    5 septembre, 2014 - 20:58

    Comme les années précédentes l’ULLM tiendra un stand lors de journée des associations qui se déroulera le samedi 20 septembre à la halle de Martigues. L’ouverture des portes au public aura lieu à 10h

    À cette occasion nous vous invitons à venir découvrir les logiciels libres et notre association.

    Nous vous proposons à partir de 14h, dans le hall de la halle, un atelier sur le montage vidéo réalisé avec des outils libres.

    Venez nombreux.

    Entrée Libre. Tout public.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Journée du logiciel libre 2014 : des activités gratuites à Québec

    5 septembre, 2014 - 10:17

    Le samedi 20 septembre 2014, la Journée du logiciel libre sera soulignée à la bibliothèque Gabrielle-Roy (350, rue Saint-Joseph Est), dans la ville de Québec. Cette journée est un évènement mondial annuel où le grand public est invité à venir découvrir l'univers des logiciels libres au travers de différentes activités. De 10h à 17h vous pourrez notamment assister à plusieurs conférences et démonstrations (programme détaillé en seconde partie) :

    • 10h à 17h - Kiosque d'information et découverte de Linux et LibreOffice
    • 10h30 - « OpenStreetMap : le dessous des cartes » (Bruno Remy)
    • 13h00 - « L'évolution du passionné des logiciels libres : de débutant à expert » (Gregory Sanderson)
    • 14h15 - « La suite bureautique LibreOffice : la liberté de faire plus que la concurrence, gratuitement… » (Raymond Ouellette)
    • 15h30 - « Les infinies possibilités du Raspberry Pi : Un exemple de succès du logiciel libre » (Jean-François Bohémier)

    Croissants, beignes et café agrémenteront également cette journée. Quel que soit votre niveau de connaissance du domaine, venez faire un tour, c’est gratuit!

    Les logiciels libres (open source – ex. Linux) sont tout simplement… partout! Incontournables, ils sont au cœur de nombreux appareils du quotidien (télévision, téléphone intelligent, routeur sans fil…) ainsi que de la majorité des sites Web, sans forcément que les gens en aient conscience. Ils reposent sur une philosophie de partage et la communauté qui les maintient va du simple passionné aux développeurs professionnels des plus grandes entreprises. Ils sont généralement très sécuritaires, robustes, rapides et même gratuits!

    Un programme varié

    L’association LinuQ – le groupe d’utilisateurs Linux de Québec –, qui organise cette journée, vous invite à prendre part aux diverses activités qui auront lieu de 10h à 17h. Vous pourrez notamment assister à plusieurs conférences et démonstrations. De plus, des spécialistes se feront un plaisir de répondre à vos questions et vous montrer comment bénéficier des logiciels libres.

    À propos de LinuQ

    LinuQ est une association sans but lucratif qui a pour vocation de promouvoir et de vulgariser les logiciels libres (open source) dans la région de Québec. Elle offre aussi aux gens intéressés l’occasion de partager leurs connaissances, leurs points de vue et leurs expériences. Présente depuis plus de 12 ans, LinuQ organise des séances d'activités bimensuelles de septembre à juin pour ses membres.

    Programme de la journée – samedi 20 septembre 2014

    10h à 17h - Kiosque d'information et découverte de Linux et LibreOffice

    Plusieurs ordinateurs seront disponibles pour permettre la découverte et l’expérimentation de divers logiciels libres.

    Conférences

    10h30 - « OpenStreetMap : le dessous des cartes » (Bruno Remy)

    Découvrez ce qu'est OpenStreetMap: une carte statique, ou une base de données vivante? Comment OpenStreetMap est-elle une plateforme d'échange de données ouvertes et libres? Pourquoi et comment OpenStreetMap repose sur la participation citoyenne? Quels sont les enjeux d'OpenStreetMap?

    13h00 - « L'évolution du passionné des logiciels libres : de débutant à expert » (Gregory Sanderson)

    Comment est-ce qu'un amateur des logiciels libres fait pour devenir un maître "geek" du domaine, respecté par tous? Venez découvrir le chemin parcouru par Gregory, un développeur professionnel de logiciels libres à Québec, à travers son histoire et ses expériences.

    14h15 - « La suite bureautique LibreOffice : la liberté de faire plus que la concurrence, gratuitement… » (Raymond Ouellette)

    Traitement de texte, tableur, présentation électronique, formules, dessin vectoriel, base de données, tout ça librement et gratuitement avec LibreOffice (pour Windows, Linux ou MacOS). On peut même faire plus que la concurrence, venez voir comment!

    15h30 - « Les infinies possibilités du Raspberry Pi : Un exemple de succès du logiciel libre » (Jean-François Bohémier)

    Venez en apprendre plus sur cet intriguant ordinateur miniature d'une trentaine de dollars, à la base de plusieurs projets innovateurs et équipé de ports réseau, USB, HDMI, audio et plus. Vous découvrirez pourquoi il suscite autant d’engouement et vous aurez peut-être envie de vous construire votre propre centre de média, serveur web, contrôle pour robotique ou même vous rapporter des photos de la stratosphère!

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Firefox 32

    4 septembre, 2014 - 14:37

    Firefox 32 vient de sortir, et voici un petit résumé des changements qui valent la peine d'être notés. Vous trouverez donc en seconde partie, des informations sur un début d'amélioration de la mémoire, un nouveau cache HTTP plus efficace, un menu contextuel simplifié, et des trucs pour développeurs : HTML 5, Scratchpad, éditeur audio web, etc.

    Changements communs Ramasse-miettes générationnel

    L'idée d'un ramasse-miettes générationnel est de limiter la fragmentation, et de gérer la mémoire différemment. C'est la première étape de ce nouveau ramasse-miettes.

    Aujourd'hui, la consommation mémoire n'a pas changé, mais les performances ont légèrement augmenté.

    L'étape suivante sera de comprimer les ensembles mémoires pour qu'ils prennent moins de place, et ainsi réduire l'empreinte mémoire de Firefox.

    Une autre priorité est l'amélioration de la gestion des pages contenant des images lourdes qui pourrait prendre moins de place. Ce travail est en cours, et devrait voir le jour plus tard.

    Nouveau cache HTTP

    Après plus d'un an de développement, le nouveau cache http est maintenant activé par défaut.

    Les données pour l'ancien cache sont supprimés de manière transparente pour ne pas gâcher d'espace et, globalement, les performances sont améliorées.

    Par exemple, Firefox utilise maintenant une heuristique appelée frecency qui modélise la probabilité de revisiter une page en fonction des visites précédentes couplé à une demi-vie d'un mois. Cette loi de demi-vie est exponentielle, un peu comme en physique.

    Le menu contextuel change

    Le menu contextuel change un peu pour devenir plus simple, et les actions importantes sont plus visibles :

    Du côté des développeurs HTML5

    Voici les nouveaux paramètres activés par défaut :

    Version de bureau Affichage du nombre d'éléments trouvés dans la barre de recherche

    Le résultat en image : 

    Du côté des développeurs Outils

    Les outils pour développeurs gèrent maintenant mieux les écrans à haute densité de pixels.

    Un nouvel éditeur audio web fait son apparition (pouf !).

    Enfin, la nouvelle Ardoise (Scrachpad en anglais), pour expérimenter avec du code JavaScript, s'est agrémentée de la complétion automatique de code et de la documentation à la volée.

    Version mobile Le passé

    La prise en charge d'Android 2.2 et des processeurs ARMv6 n'est plus assurée pour les nouvelles versions de Firefox. La version 31 va être maintenue pour ces utilisateurs jusqu'en janvier prochain.

    GamePad API

    L'API permettant de gérer les manettes de jeux est terminée et activée par défaut.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    0.joie, une nouvelle version de Weboob

    4 septembre, 2014 - 14:37

    Weboob (Web Outside Of Browsers) est un ensemble d'applications interagissant avec des sites Web.

    En ces temps de rentrée, une nouvelle version de Weboob arrive pour vous accompagner. Weboob 0.j enjoue le Web depuis hier.

    Cette nouvelle version est assez calme, avec environ 300 commits provenant de 13 contributeurs. Elle inclut cependant de nombreuses corrections de bugs, et peut être vue comme la version bêta de la 1.0 à venir.

    Les nouveautés sont détaillées en seconde partie de la dépêche. Weboob compte désormais 165 modules, gérant davantage de sites (certains modules pouvant concerner plusieurs sites Web).

    Sommaire Export à l'international avec Wells Fargo et Twitter

    Les fondateurs et la grande majorité des développeurs du projet sont francophones, ce qui introduit un biais sur la sélection des modules. Ainsi, tous les sites bancaires étaient jusqu'à présent des sites de banques françaises. On avait été parfois approché par des développeurs pour des banques à l'étranger, mais sans que cela n'aboutisse à des contributions concrètes. C'est désormais fait ! Cette version inclut en effet le module pour la banque Wells Fargo.

    Dans la même veine, même si il a été développé par un francophone, un module Twitter a fait son apparition, amenant définitivement Weboob à la pointe des technologies de communication modernes.

    Plugin XBMC/Kodi

    L'intégration de Weboob dans des applications spécialisées est toujours un objectif. Cela permet une bien meilleure expérience utilisateur, et nous permet de rester concentrés sur les sites Web plutôt que de développer des applications compliquées.
    Nous sommes donc très heureux de présenter un plugin pour le lecteur XBMC/Kodi. Il permet de rechercher et visionner des vidéos en provenance de tous les sites gérés par Videoob:

    Le plugiciel est disponible dans le dossier contrib.

    Browser2 et les opérateurs binaires

    Nous présentions lors de la dernière dépêche le nouveau navigateur, permettant de simplifier l'extraction des données des sites Web. Cette simplification passe notamment par des filtres spécialisés, recherchant facilement les éléments du DOM, effectuant des traitements dessus et convertissant automatiquement les données au bon format (que ce soit un entier, une date, etc.). Ces filtres évitent d'écrire une conversion de texte en date dans chaque module. On peut imbriquer les filtres, afin d'obtenir un enchaînement assez puissant sans beaucoup de code :

    obj_duration = Duration(CleanText('//div[@id="video_text"]'))

    Comme le code semble l'indiquer, on extrait d'abord le texte que l'on convertit ensuite en durée.

    Cette encapsulation entre les différents filtres se fait parfois avec plusieurs niveaux, rendant le code un peu moins lisible. Pour résoudre cela, cette version introduit deux nouveautés basées sur les opérateurs binaires. Le premier est le &, qui permet d'enchaîner deux filtres dans le sens naturel. On pourra ainsi réécrire la ligne par :

    obj_duration = CleanText('//div[@id="video_text"]') & Duration

    Le second, |, est utilisé pour définir une valeur par défaut, dans le cas où les filtres n'arrivent pas à convertir les données (notamment parce que la donnée n'est pas disponible sur le site lui-même ou qu'elle n'a pas le format attendu). Petit exemple de code réel :

    obj_duration = CSS('span.thumbtime span') & CleanText & Duration | NotAvailable

    Ces opérateurs, optionnels, augmentent la palette des outils à disposition des développeurs de modules, rendant l'écriture de ceux-ci beaucoup plus aisée.

    Pour plus d'informations sur le nouveau navigateur et son système de filtres, vous pouvez retrouver une série d'articles publiée (en français) sur le Planet Weboob.

    En route vers la 1.0

    Cette version sonne la dernière étape vers une stabilisation de Weboob et une sortie prochaine de la 1.0. Un travail d'uniformisation de l'API de développement a ainsi été effectué afin de pouvoir rentrer sereinement dans un cycle permettant la conservation de la rétro-compatibilité.

    Cette uniformisation a cependant un coût temporaire : les outils externes utilisant Weboob comme bibliothèque doivent être mis à jour. Dans la même veine, le paquet Debian a été un peu nettoyé et rangé, et l'emplacement des plugins munin a notamment été modifié.

    Nous sommes pour le moment dans les temps par rapport à notre planning prévisionnel pour la sortie de la version 1.0, prévue avant le gel de la distribution Debian.

    La documentation développeur fait peau neuve

    Un effort particulier a été réalisé durant ce cycle de développement pour améliorer la documentation. Nous avons ainsi refait la page d'accueil du site pour développeur, actualisé les guides et réorganisé la structure. Ce qui était parfois divisé entre le Wiki et la documentation est désormais intégralement sur le site dédié. Accessoirement, nous avons changé l'adresse du site, en passant de docs.weboob.org à dev.weboob.org.

    Petites nouvelles

    Les imports Python ont été réorganisés, pour réduire sensiblement le temps de chargement des applications simples (division par deux pour la plus simple des applications).
    À la manière de l'utilitaire ip il est possible, pour économiser quelques lettres lors de l'écriture des commandes, de réduire les noms des modules (arte peut ainsi être écrit ar, voir a). Cela s'ajoute au nom des commandes déjà réduites.

    Enfin, deux autres modules font leur apparition. Ils permettent d'accéder aux sites Feedly et Oney Banque

    La prise en charge de Python 3 a été améliorée. Le projet reste en Python 2, mais certaines parties du core, et les modules compatibles, sont déjà utilisables avec Python 3.

    L'application radioob gère maintenant les albums et les playlists :

    $ radioob -b grooveshark search album sixsixsixteen album.8163226@grooveshark — Blood Duster (Blood Duster) $ radioob -b grooveshark play album.8163226@grooveshark

    Le module arte prend en charge les podcasts.

    Contributeurs

    Merci aux contributeurs qui ont participé à cette version :

    • Benjamin Carton
    • Florent Fourcot
    • Jean-Philippe Dutreve
    • Julien Hebert
    • Laurent Bachelier
    • Oleg Plakhotniuk
    • Romain Bignon
    • Simon Murail
    • Tanguy Ortolo
    • Tens San
    • Vincent A
    • Vincent Paredes
    • Vincent Texier

    Weboob est un projet qui grossit et qui vit grâce à ses contributeurs. Si vous souhaitez l’améliorer, que vous connaissiez le Python ou pas, n’hésitez pas à contribuer.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Un ebook sur AngularJS à prix libre et pour une bonne cause

    4 septembre, 2014 - 14:13

    Devenez un Ninja avec AngularJS : un ebook à prix libre et en soutien à une association caritative.

    Ninja Squad propose un livre permettant de découvrir ou d'approfondir ses connaissances du framework web AngularJS. Sur le modèle des Humble Bundle, cet ebook est proposé à prix libre, et en soutien optionnel à une association caritative : Docteur Souris, qui fournit des ordinateurs et des accès internet sécurisés pour les enfants hospitalisés.

    Si AngularJS est un framework web extrêmement puissant, il est aussi très exigeant. Il permet d'atteindre des vitesses de développement inégalées, pour peu que l'on prenne le temps de le maîtriser.
    Ce livre devrait vous permettre de comprendre en détails tous les principes et pratiques d'AngularJS, des bases aux dernières nouveautés introduites par la version 1.3.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Les ateliers CLI (prochain le 8 septembre 2014 à Bègles)

    4 septembre, 2014 - 13:23

    Les ateliers CLI sont organisés par des libristes girondins comme une formation d'initiation à la ligne de commandes pour permettre aux nouveaux de gagner en autonomie. Ils reprendront lundi 8 septembre 2014 à 19h00 à 20h30 (avec un rythme d'un tous les quinze jours), dans les locaux du L@BX à la Fabrique Pola (ancien centre de tri à Bègles).

    Ils sont encadrés par des membres bénévoles de deux associations et un collectif du libre : ABUL (Association Bordelaise des Utilisateurs de Logiciels libres), L@bX (Hacklab hébergé à la Fabrique POLA) et GIROLL (Gironde Logiciels Libres). L'an passé, nous avons abordés des bases comme copier un fichier, lire un fichier, etc. Nous nous sommes également amusés avec Tmux, SSH, AWK, etc. Ces ateliers sont gratuits et sont ouverts à tous ceux qui le souhaitent : membres d'associations, particuliers, étudiants… Pour tout renseignement envoyez un courriel à jmaxker58 at gmail point com

    Genèse

    Au commencement, il y avait la doc. Puis, un regroupement d'amis faisant partie de quelques associations du libre s'est formé à Bordeaux. En 2011, ils décidèrent de s'unir pour créer des ateliers sur des logiciels libres que l'on utilise en ligne de commande. Leur but étant de partager les connaissances et progresser ensemble.

    Évolution

    Le groupe a augmenté et quelques débutants ont commencé à nous rejoindre. Nous avons donc mis en place une approche pour débutants. Les ateliers dispensent désormais une formation d'initiation à la ligne de commande pour permettre aux nouveaux de gagner en autonomie. Les questions les plus basiques sont abordées et l'apprentissage des réflexes de navigation dans l'arborescence des répertoires est un passage important pour la compréhension des concepts abordés. Nous démontrons que l'utilisation de la ligne de commande permet notamment de gagner du temps face à une interface graphique.

    Le projet

    Pour cette nouvelle session nous allons mettre en pratique les notions vues précédemment. Trouver un projet qui permettrait de faire quelque chose d'utile à monsieur tout le monde. Vous rentrez de vacances et avez trié vos photos que vous souhaitez envoyer à l'ensemble de votre famille avec un petit mot personnalisé. Voici un projet qui permettra de mettre en avant les capacités de la ligne de commande.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Appel à communications - Drupagora le 14 novembre 2014 à Paris

    4 septembre, 2014 - 13:20

    Drupagora, premier évènement francophone sur Drupal dédié aux chefs de projets et DSI, se tiendra cette année le vendredi 14 novembre à Paris.

    Cette journée, organisée autour de conférences techniques et non techniques, de retours d’expérience et d’ateliers pratiques, est le rendez-vous incontournable de tout l’éco-système Drupal et attire chaque année plus de 350 professionnels, venus d’Ile de France et de Province.

    Maxime Topolov, co-fondateur et CTO d’Adyax (société de services leader Drupal sur le marché européen), s'est vu confier le soin de définir les grandes thématiques du programme et de sélectionner, avec le comité de pilotage, les intervenants pour cette nouvelle édition (voir la seconde partie pour les détails de l'appel à communications).

    Cette année, le fil rouge du programme sera : Drupal dans l'entreprise : projets complexes et intégrés au SI, plateformes digitales globales, sites e-commerce et applications métier.

    Thématiques principales
    • Plateformes digitales globales : distributions et usines à sites
    • E-commerce avec Drupal pour les sites à > 5M€ de CA
    • Applications métier avec Drupal (intranets, RSE, bases documentaires, outils métiers)
    • Drupal face à la concurrence des principaux éditeurs (Oracle, Adobe, Sitecore, Ektron, Demandware, Hybris…)

    • Vous êtes expert sur un domaine lié aux technologies du web ?

    • Vous avez utilisé Drupal dans un contexte spécifique (référencement, forte charge, client reconnu, projet innovant) ?

    • Vous participez à un projet Open Source lié à Drupal ?

    Cet évènement est le vôtre ! Venez partager votre expérience !

    Pour soumettre votre sujet de conférence, envoyez votre proposition : http://www.drupagora.com/2014/appel-a-communications

    Date limite d’envoi de proposition : 29 Septembre 2014

    Informations complémentaires Date, lieu et organisation

    La conférence Drupagora se tient à la Maison des Associations, 10-18 rue des Terres au Curé, Paris 13ème, métro Olympiades ou Porte d'Ivry, le vendredi 14 novembre de 9h à 18h. La conférence se déroule sur une journée avec une programmation qui sera consultable sur le site drupagora.com.

    Accès

    Tarif entrée : 150 euros la journée
    100 euros jusqu'au 14/10/2014
    100 euros pour les membres de Drupalfr

    Organisation

    L'organisation de la conférence Drupagora est pilotée par un comité de programme composé d'experts reconnus sur Drupal.

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Atelier VirtualBox le 11 octobre 2014 à Argenteuil

    3 septembre, 2014 - 10:14

    Dans le cadre de ses ateliers bi-mensuels, l'association StarinuX a le plaisir de vous convier à l'atelier Virtualbox. L'atelier se tiendra le samedi 11 octobre 2014 de 9h00 à 18h00 aux Bains-douches Silicone Banlieue, 26 rue de Calais 95100 Argenteuil.

    Apprenez à virtualiser un système d'exploitation avec un outil Opensource réputé. Un atelier concret et pratique qui est une véritable compréhension et introduction vers la route du cloud.

    Précision : l'atelier est ouvert selon une participation annuelle de 20 € (10 € demandeur d'emplois), valable pour plus de 18 ateliers.

    Courriel : events CHEZ starinux.org

    Télécharger ce contenu au format Epub

    Lire les commentaires

    MesaMatrix pour suivre les progrès de Mesa

    3 septembre, 2014 - 09:36

    À chaque fois que je lis les dépêches LinuxFr sur le nouveau noyau ou bien les nouvelles de Phoronix, je m'empresse de regarder les avancées des pilotes graphique libres. Et souvent, je vais sur la page Mesa traçant les évolutions de l'implémentation d'OpenGL. Mais je trouve difficile de suivre où en est réellement la progression de cette adaptation dans Mesa et de ses différents pilotes graphiques qui en dépendent. C'est pourquoi j'ai décidé de faire un script qui parcourt ce fichier et l'affiche de manière plus intelligible.

     http://creak.foolstep.com/mesamatrix/

    Si vous adorez suivre la course qui se tient entre Mesa et OpenGL, et que vous allez souvent voir quelles sont les nouvelles extensions OpenGL qui ont été implémentées et pour quels pilotes, ça pourrait vous intéresser! Plus d'explications dans la suite de la dépêche.

    MesaMatrix

    MesaMatrix est écrit majoritairement en PHP pour récupérer le fichier texte source, le parcourir et afficher le tout au format HTML. Il y a aussi un peu de CSS et de Javascript (néanmoins pas obligatoire pour que le site fonctionne). Et parce que je crois dur comme fer au mouvement Libre, le tout est mis sous licence GPLv3.

    Le fichier texte source n'étant pas spécialement formaté pour être parcouru par un script, il a fallu quelques commits avant d'avoir une page fonctionnelle, mais fort heureusement des personnes ont reportés les bogues et Tobias Droste a même proposé des pull requests pour peaufiner tout ça.

    Récemment, j'ai rajouté des compteurs pour savoir où en est l'implémentation d'OpenGL dans Mesa, ainsi que dans chaque pilote.

    Intérêt

    Grâce à ce projet, j'ai pu mieux comprendre comment était structuré l'implémentation de Mesa et de ses pilotes. Et j'espère que cela pourra aider d'autres personnes à comprendre.

    Maintenant, nous avons un moyen simple de suivre l'évolution de Mesa. Nous voyons plus clairement le chemin parcouru et celui qu'il reste à faire avant d'avoir une version complètement fonctionnelle d'OpenGL 4.5.

    On peut voir qu'à ce jour, il ne reste plus que trois extensions à implémenter dans Mesa pour qu'OpenGL 4.0 soit complet. Et ensuite, nous sommes à seulement trois autres extensions pour arriver directement à OpenGL 4.2. Cependant il va rester encore pas mal de travail pour implémenter ces extensions dans chaque pilote.

    Parlant des pilotes, c'est souvent assez confus de savoir qui fait quoi. Les pilotes intitulés "softpipe", "swrast" et "llvmpipe" sont dit software car ils ne dépendent d'aucun matériel. À l'inverse, les pilotes "i965" (Intel), "nv50" et "nvc0" (nVidia), et "r300", "r600" et "radeonsi" (AMD) sont dits hardware car dépendant de puces graphiques bien précises.

    Vous voulez participer?

    Aucun souci ! Que ce soit pour des suggestions de nouvelles fonctionnalités, des découvertes de bogues ou même des pull requests, le projet est sur GitHub, vous pouvez en faire ce que vous voulez (dans la limite de la licence GPLv3 évidemment ;)).

    Télécharger ce contenu au format Epub

    Lire les commentaires

    Sortie d'ownCloud 7.x

    3 septembre, 2014 - 07:48

    OwnCloud, le logiciel pour héberger ses données personnelles est maintenant en version 7.0.2.


    OwnCloud permet d'héberger ses propres services « dans les nuages » (SaaS : Software as a Service), sans dépendre d'autres intervenants. Fort de près de 300 contributeurs dans les 12 derniers mois, C'est un projet dynamique, écrit en PHP, et utilisant Mysql, PostgreSQL ou SQLite comme base de données.

    Les nouveautés sont détaillées en seconde partie ; on notera l'interface revue et "responsive", le partage de données entre serveurs ownCloud, les formats d'imports du carnets d'adresse et une interface avec les anti-virus.

    Les principales fonctionnalités d'ownCloud
    • stockage et partage de fichiers ;
    • carnet d'adresses ;
    • calendrier ;
    • gestionnaire de tâches ;
    • synchronisation avec les smartphones ;
    • synchronisation des préférences de Mozilla Firefox ;
    • édition de fichiers ODT (OpenDocument Text) en ligne.

    Le tout également en partage avec d'autres utilisateurs. Ces options ont reçu quelques améliorations dans la version 7 comme le montre cette image :

    OwnCloud dispose d'un mécanisme de modules qui permet de développer et d'ajouter de nombreuses fonctionnalités. De nombreux modules sont déjà disponibles.

    Nouveautés pour les utilisateurs dans la version 7 Général
    • Nouvelle interface, fini le menu d'application fixe à gauche, vive le menu dynamique en haut à gauche !
    • Une interface adaptée aux terminaux mobiles
    • Amélioration des performances.

    Fichiers
    • Connexion et partage entre serveurs ownCloud
    • Plus de possibilités lors du partage de fichiers
    • Gestion des fichiers au format Microsoft Word et ODT (OpenOffice)
    • Onglet File Activity permettant de connaître les changements dans les fichiers de l'utilisateur ou ses fichiers partagés.

    Carnet d'adresses
    • Import de multiples formats (csv, vcard, gmail, ldif…)
    Nouveautés pour les administrateurs
    • Une interface de gestion des utilisateurs totalement modifiée
    • La possibilité d'utiliser du stockage de type FTP, Dropbox, Google Drive, sFTP, Swift, S3, WebDAV ou SMB/CIFS
    • Une interface générique avec les anti-virus pour contrôler tous les fichiers ajoutés
    • Une interface avec LDAP et AD améliorée, en particulier avec un grand nombre d'utilisateurs
    • Un assistant de configuration pour l'envoi des emails (SMTP) et la possibilité de modifier les mails envoyés par ownCloud
    • Une amélioration de la gestion des modules
    • Une gestion plus fine des quotas, y compris sur les stockages externes.

    Nouveautés pour les développeurs de modules
    • Un système de fonctions de rappel permettant aux modules de s'abonner à des notifications et d'en envoyer.
    • Pour les clients lourds, la possibilité de distinguer de quelle façon sont partagés les fichiers : est-ce qu'on est propriétaire ou non ? est-ce que le fichier est partagé ou non ?
    • Une mise à jour de la documentation.

    Une conférence et un hackathon pour les développeurs ownCloud se sont par ailleurs déroulés du 26 au 30 août 2014 à Berlin.

    D'autre part, toujours en Allemagne, un important déploiement (concernant près d’un demi-million d'utilisateurs), va se faire pour les étudiants et employés de 18 universités.

    Télécharger ce contenu au format Epub

    Lire les commentaires