Nouvelles du Libre

Fortinet : une nouvelle responsable Channel France

Toolinux - mer, 16/07/2014 - 23:00

L'éditeur de solutions de sécurité Fortinet annonce la nomination de Jennyfer Beauregard au poste de Responsable Channel France.

- Communiqué
Catégories: Nouvelles du Libre

Un rapport parlementaire recommande l'utilisation du logiciel libre

Linuxfr - mer, 16/07/2014 - 07:57

Le Sénat vient de publier un rapport d’information rédigé par Mme Catherine Morin-Desailly, intitulé “Nouveau rôle et nouvelle stratégie pour l’Union européenne dans la gouvernance mondiale de l’Internet”. Le logiciel libre y est présenté comme “une alternative intéressante pour l’Europe et la France […] face à la progression des systèmes fermés et des considérations marchandes dans l’univers de l’Internet”.

L'importance de la filière du logiciel libre en France y est notée, de nombreux arguments en faveur de l'utilisation du logiciel libre sont avancés, et plusieurs propositions sont faites pour "encourager les compétences nationales par une politique adaptée" :

  • non brevetabilité des logiciels ;
  • intégrer les logiciels libres dans les marchés publics ;
  • imposer les standards ouverts ;
  • développer les compétences autour des logiciels libres et des standards ouverts, en encourageant notamment l'usage des logiciels libres dans les enseignements informatiques.

Le Conseil National du Logiciel Libre se réjouit de la prise en compte dans le rapport de la filière économique du logiciel libre en France, qu’il représente :

Le Conseil national du logiciel libre (CNLL) a rendu compte du succès croissant des formats libres de logiciels : représentant 6 % de l’ensemble des logiciels et services, soit une valeur de 2,5 milliards d’euros, ils occupent 30000 personnes – dont 3000 chez les « pure players » – réparties dans 300 entreprises, essentiellement des PME et TPE. La filière, qui a crû de 68 % en 2012, devrait avoir progressé de 83 % en 2013. [Note: ces chiffres sont extraits de l'enquête 2013 du CNLL, mais ont été mal interprétés.]

[…]

Depuis 2003, plusieurs clusters et associations d’entreprises du logiciel libre ont été mis en place en vue de fédérer les moyens et les projets développés dans le secteur : Prolibre, Libertis, Alliance libre, GTLL, PLOSS, PLOSS RA et Aquinetic, répartis sur l’ensemble du territoire et regroupés au sein du CNLL. Ce riche écosystème a donné naissance à plusieurs jeunes pousses en pleine ascension, à l’image de la première d’entre elles, l’éditeur de logiciels libres Talend.

Notre pays dispose donc d’importantes ressources et compétences dans le domaine du logiciel libre, qu’il lui faut aujourd’hui pousser davantage pour maintenir et conforter cet atout économique autant que stratégique.

De nombreux arguments en faveur des logiciel libres sont avancés dans le rapport :

  • ils sont “sources d’économies et de compétitivité” ;
  • ils permettent “d’innover à moindre coût” ;
  • ils permettent de “réduire la dépendance, stratégique et économique, de la France vis-à-vis de fournisseurs étrangers” ;
  • ils sont “plus protecteurs en termes de sécurité”.

Formellement, le rapport recommande l’approche suivante pour favoriser le développement du logiciel libre :

Proposition n° 43 : encourager le développement des logiciels libres par leur intégration dans les marchés publics et par l’imposition de standards ouverts, à condition de développer les compétences pour l’utilisation de ces logiciels et standards.

Il vient également appuyer un souci très ancien des écosystèmes du libre et de l’open source, en condamnant la brevetabilité des logiciels :

Proposition n° 42 : veiller à la préservation du principe européen de non-brevetabilité des logiciels.

Le rapport note à juste titre qu’il s’agit d’une promesse de campagne du Président Hollande.

Enfin, dans le domaine de l’éducation, il est noté que :

[…] il paraîtrait de bonne politique d’encourager l’usage des logiciels libres dans les enseignements informatiques. Basé sur l’ouverture et la collaboration, valeurs en phase avec la démarche scientifique, le logiciel libre peut être étudié librement de droits. Et la formation supérieure aux méthodes de création de logiciels libres peut conduire à d’importants débouchés professionnels.

Le CNLL se réjouit particulièrement du ton général de ce rapport, et de ces recommandations concrètes, qui rejoignent et renforcent les “10 propositions pour une politique du logiciel libre” qu’il a publié en 2012, et notamment ses propositions suivantes :

  • proposition 1 : obligation d'utiliser les standards ouverts ;
  • proposition 2 : recommandation d'utiliser le logiciel libre, à coût global, risques et efficacité comparables ;
  • proposition 4 : faire barrage aux brevets logiciels ;
  • proposition 5 : pour des standards ouverts vraiment ouverts ;
  • proposition 6 : agir pour préserver la neutralité du Net ;
  • proposition 9 : recommandations relatives au libre dans l'éducation.

Le rapport complet peut être téléchargé sur le site web du Sénat. Les pages qui concernent le plus spécifiquement le logiciel libre sont les pages 267 à 272.

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Mozilla veut améliorer l'encodage des images JPEG

Toolinux - mar, 15/07/2014 - 23:59

Mozilla vient de livrer la nouvelle version de mozjpeg, encodeur JPEG permettant de réduire la taille des fichiers JPEG de 5% en moyenne.

- Logiciels
Catégories: Nouvelles du Libre

Cerberus 1.0.0 disponible.

Linuxfr - mar, 15/07/2014 - 23:34

Nous sommes heureux d'annoncer la sortie de la version 1.0.0 de Cerberus. Pour mémoire, Cerberus est un outil de test pour les applications web, les applications back office et les tests d'infocentres et outils décisionnels.
Cette version majeure voit le jour suite à l'ajout de trois fonctionnalités :

  • la gestion de campagne de tests, lien essentiel entre les cas de tests et la Release ;
  • l'intégration de nouveaux frameworks de tests permettant des tester fonctionnellement des web services ;
  • l'affichage en temps réel de l'exécution des tests (même lancés sur un serveur distant).

Cerberus entend porter la méthodologie du développement piloté par les tests (Test Driven Development), en mettant à disposition des acteurs du développement (depuis les phases de définition jusqu'à la validation, en passant par la phase de développement elle-même) un socle d'information fonctionnelle et technique commun.

Finie l'utilisation de deux outils distincts pour décrire les tests et automatiser ceux-ci : décrire un cas de tests revient à implémenter celui-ci (de part l'utilisation de bibliothèques de données ou de groupement d'actions). Cette façon de structurer l'information rends les tests bien plus facilement maintenables dans le temps.

Les tests peuvent être lancés par tous via l'application, ou en mode batch pour une campagne de tests par exemple (sur plusieurs queues, plusieurs navigateurs et plusieurs environnements simultanément). Les compte-rendus d'exécution s'accompagnent désormais du code source des pages testées et des logs Selenium (vue serveur et vue navigateur), en plus des captures d'écran pleine page, ainsi que des logs Cerberus sur chaque action. Cela permet l'analyse des résultats par plusieurs personnes et selon différents besoins.

Dans une prochaine version, nous intégrerons notamment une interface à framework de tests d'application mobile (Appuim), poursuivant notre stratégie de centraliser les tests quelques soient les technologies.

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

beCPG, de l'open source dans le monde du PLM

Toolinux - mar, 15/07/2014 - 23:30

beCPG PLM s'annonce comme la première solution de PLM Open Source 100% dédiée au secteur des biens de grande consommation.

- Logiciels
Catégories: Nouvelles du Libre

Zend Studio 11 pour des applications PHP plus mobiles

Toolinux - mar, 15/07/2014 - 23:25

En plus d'une nouvelle griffe de tarifs, la nouvelle version de Zend Studio booste, selon son éditeur, le support de PHP sur Eclipse, facilite le développement de Services Web et les déploiements dans le cloud.

- Développement
Catégories: Nouvelles du Libre

Open Virtual Desktop 4.0.2 appuie sur start

Toolinux - mar, 15/07/2014 - 23:24

Ulteo annonce la disponibilité d'Open Virtual Desktop 4.0.2 et d'un programme de démarrage rapide, "Quick Start".

- Services
Catégories: Nouvelles du Libre

Le phénomène shadow IT, cauchemar pour les entreprises

Toolinux - mar, 15/07/2014 - 23:13

Une meilleure coopération avec les employés, de nouveaux outils et de nouveaux processus d'obtention de services informatiques pour contrer le phénomène du Shadow IT. Une tribune libre de Yannick Hello, Responsable S-EMEA chez Ipswitch.

- Revue de presse
Catégories: Nouvelles du Libre

QNAP : un NAS mobile 7-en-1, QGenie

Toolinux - mar, 15/07/2014 - 23:11

QNAP vient d'annoncer la sortie de QGenie, un NAS mobile qui permettra le stockage de fichiers, le partage de connexion internet et pourra servir de station de recharge mobile.

- Matériels
Catégories: Nouvelles du Libre

Des avancées pour le rapport parlementaire Morin-Desailly dans le domaine du logiciel libre et des standards ouverts

Toolinux - mar, 15/07/2014 - 23:10

Le Sénat vient de publier un rapport d'information rédigé par Mme Catherine Morin-Desailly, intitulé “Nouveau rôle et nouvelle stratégie pour l'Union européenne dans la gouvernance mondiale de l'Internet”. Le logiciel libre y est présenté comme “une alternative intéressante pour l'Europe et la France [...] face à la progression des systèmes fermés et des considérations marchandes dans l'univers de l'Internet”.

- Communauté
Catégories: Nouvelles du Libre

RMLL 2014 : l'album photo de Linagora et TOOLinux

Toolinux - mar, 15/07/2014 - 17:58

Nos partenaires de Linagora ont assisté aux Rencontres mondiales du logiciel Libre (RMLL) 2014 qui ont eu lieu à Montpellier du 5 au 11 juillet 2014. Son album photo est en ville.

- Revue de presse
Catégories: Nouvelles du Libre

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

Linuxfr - mar, 15/07/2014 - 17:18

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

[Le Point] L'enseignement du langage informatique proposé en primaire dès la rentrée

Par la rédaction, le dimanche 13 juillet 2014. Extrait:

L'enseignement du langage informatique sera proposé en primaire dès la rentrée de manière facultative, annonce dans une interview au Journal du dimanche le ministre de l'Education nationale Benoît Hamon, qui prévoit également de relier au haut débit hertzien 9.000 écoles dès septembre.

Lien vers l'article original: http://www.lepoint.fr/societe/l-enseignement-du-langage-informatique-propose-en-primaire-des-la-rentree-13-07-2014-1845757_23.php

[Slate.fr] Tor, de plus en plus partagé

Par Amaelle Guiton, le jeudi 10 juillet 2014. Extrait:

Boosté par les scandales de surveillance numérique, le réseau d'anonymisation enregistre depuis un an un afflux conséquent d'utilisateurs. Ce changement d'échelle et de périmètre pose à ses développeurs des défis complexes.

Lien vers l'article original: http://www.slate.fr/story/89673/tor

Et aussi:

[CitizenKane] Sécurité informatique: 4 bombes atomiques en 12 mois

Par David Nataf, le jeudi 10 juillet 2014. Extrait:

Nos systèmes de sécurité informatique sont bien plus nombreux et perfectionnés qu’il y a quelques années. Les normes de sécurité et leur intégration dans les entreprises sont de mieux en mieux implémentés. Et pourtant, ces derniers 12 mois ne nous ont pas gâté. Avec peut-être les 4 plus grandes bombes à retardement jamais vues en sécurité informatique.

Lien vers l'article original: http://citizenkane.fr/securite-informatique-4-bombes-atomiques-en-12-mois.html

[Solutions-Logiciels.com] Linux: trois événement majeurs lui seront consacrés du 13 au 15 octobre

Par Juliette Paoli, le jeudi 10 juillet 2014. Extrait:

Le créateur de Linux, Linus Torvalds, et les dirigeants d'Amazon et de ownCloud ont répondu présents aux prochains événements organisés par la Fondation Linux du 13 au 15 octobre au Centre des Congrès de Düsseldorf. Trois événements en un avec LinuxCon, CloudOpen et Embedded Linux Conference Europe.

Lien vers l'article original: http://www.solutions-logiciels.com/actualites.php?titre=Linux-trois-evenement-majeurs-lui-seront-consacres-du-13-au-15-octobre&actu=14806

[Next INpact] Suite au «fail» de la DILA, Regards Citoyens publie un guide sur l’Open Data

Par Xavier Berne, le mardi 8 juillet 2014. Extrait:

Suite aux différents problèmes qui ont accompagné la mise à disposition, gratuite, des données juridiques détenues par la Direction de l'information légale et administrative (DILA), l’association Regards Citoyens vient de publier un «petit guide à destination des administrations souhaitant basculer du payant à l’Open Data». L’occasion pour l’organisation de revenir de manière synthétique sur le processus d’ouverture et de partage de données publiques, tout en insistant sur le récent épisode de la DILA, qui est considéré comme «l’un des plus gros «fail» administratifs en matière d’Open Data».

Lien vers l'article original: http://www.nextinpact.com/news/88585-suite-au-fail-dila-regards-citoyens-publie-guide-sur-l-open-data.htm

[Wired] Out in the Open: The Crusade to Bring More Women to Open Source

Par Klint Finley, le lundi 7 juillet 2014. Extrait:

De récents rapports de Facebook et Google confirment ce que nous avons toujours su: les géants de la technologie ont un problème de diversité. Mais dans le monde open source, le problème est encore pire.

Lien vers l'article original: http://www.wired.com/2014/07/openhatch

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Séminaire : "Supervision & Métrologie Réseau, une combinaison parfaite"

Toolinux - lun, 14/07/2014 - 23:20

La division Network Management d'Ipswitch, SecurActive et Orsenna préparent plusieurs matinées de séminaires. Lyon est la prochaine étape en septembre.

- Evénements et séminaires
Catégories: Nouvelles du Libre

HandyLinux-1.6 : les versions française et anglaise en fusion

Toolinux - lun, 14/07/2014 - 23:16

Debian 7.6 est sortie le 12 juillet. Sans attendre, la nouvelle mouture de la distribution HandyLinux - "Debian sans se prendre la tête" - pointe le bout de son nez. Quoi de neuf ?

- Logiciels
Catégories: Nouvelles du Libre

Explorez votre arborescence Linux avec tree

Toolinux - lun, 14/07/2014 - 23:05

Comment explorer simplement (et avec style) une arborescence sous Linux ? Voici un outil qui permet d'afficher clairement une arborescence donnée ainsi que ses différentes options : il s'agit de “tree”.

- Logiciels
Catégories: Nouvelles du Libre

Découvrez les logiciels libres à Marseille le 26 juillet

Toolinux - lun, 14/07/2014 - 23:05

L'association CercLL annonce son prochain atelier du le samedi 26 juillet. Cet atelier s'adresse plus particulièrement aux débutants soucieux d'utiliser de manière plus rationnelle leur ordinateur.

- Evénements et séminaires
Catégories: Nouvelles du Libre

Gouvernance d'Internet : l'avenir des réseaux est avant tout technologique

Toolinux - lun, 14/07/2014 - 23:00

En mars dernier, le gouvernement américain a déclaré abandonner la gouvernance d'Internet ainsi que la gestion des adresses IP. Plusieurs questions restaient alors en suspens : comment envisager l'avenir d'Internet ?

- Revue de presse
Catégories: Nouvelles du Libre

Sortie de KDE Frameworks 5

Linuxfr - lun, 14/07/2014 - 19:54

KDE Frameworks 5 (KF5) est sorti le 7 juillet 2014 ! Pour rappel, KF5 c’est le résultat de 3 ans d’efforts pour modulariser les KDElibs, les bibliothèques utilisées par la plupart des logiciels KDE. À cette occasion, elles ont été migrées vers Qt5 et améliorées. Une itération majeure donc, mais une évolution et pas une révolution, ce qui facilite la transition.

La modularisation est un objectif de longue date pour rendre les KDElibs utiles aux développeurs Qt. En effet, les bibliothèques KDE sont, au fur et à mesure de leur évolution, devenues un véritable cadriciel (framework) ou, plutôt, un ensemble de bibliothèques interdépendantes ; ce côté monolithique souvent reproché aux KDElibs limitait son utilité en dehors de KDE.

Note: Cette dépêche est essentiellement une traduction des notes de versions et d'un choix de documentations sur les API de KF5 issus du planet KDE, notamment ces trois .

Sommaire Historique

Quand KDE a été lancé, il y a 15 ans, le développement était centré sur les applications et les bibliothèques arrivaient ensuite, lorsqu’une fonctionnalité était utilisée dans plusieurs applications. Aujourd’hui, les bibliothèques KDE sont la base commune de presque toutes les applications KDE, fournissant des fonctionnalités haut niveau comme les barres d’outils ou les menus, la vérification orthographique et l’accès aux fichiers.

À l’heure actuelle, « KDELibs » est distribué comme un ensemble de bibliothèques interconnectées. Dans le cadre du travail sur KDE Frameworks 5, ces bibliothèques ont été méthodiquement réusinées en un ensemble de modules indépendants et multiplateformes qui seront accessibles à tous les développeurs Qt.

KDE Frameworks, conçu comme une extension à Qt, va enrichir l’environnement de développement de Qt avec des fonctions qui simplifient, accélèrent et réduisent le coût du développement Qt. Par exemple, KArchive (un des premiers cadriciels disponibles) offre la prise en charge de nombreux algorithmes de compression dans une bibliothèque indépendante et simple à utiliser. Envoyez-lui simplement des fichiers ; il n’y a pas besoin de réinventer une fonction d’archivage.

La transition de plateforme à Frameworks est en cours depuis presque 3 ans et est menée par les meilleurs contributeurs KDE. Il a été décidé que les versions de KF5 sortiraient avec un cycle plus adapté au développement des cadriciels de KF5, différent de celui de l’espace de travail Plasma. KF5 devient donc un projet à part de la communauté KDE.

Découpage et dépendances

Les cadriciels de KF5 sont classés selon deux axes :

  • Tiers :

    • tiers 1 : aucune dépendance aux autres composants KF5 ;
    • tiers 2 : dépendance possible aux tiers 1 ;
    • tiers 3 : dépendance possible à un autre tiers 3 et aux tiers en-dessous.
  • Type (voir plus bas) :

    • fonctionnel ;
    • intégration ;
    • solution.
Cadriciels fonctionnels

Ces cadriciels sont indépendants. Ils n’ont pas de dépendance à l’exécution, mais offrent une fonctionnalité de haut niveau. La liste suivante n'est pas exhaustive quant au nombre de cadriciels disponibles, elle en présente les principales nouveautés.

KArchive est un cadriciel qui prend en charge les archives compressées dans des formats populaires tels zip, 7z et tar, et propose une compression QIODevice pour gzip, bzip2 et xz. KArchive peut extraire n’importe quel fichier dans l’un des formats pré-cités.

KPlotting est un cadriciel de graphe simple qui gère l’anti-crénelage (anti-aliasing), l’empilage et la mise à jour. Il s’occupe de transformer les données soumises en un graphique avec ses axes et ses étiquettes (il prend en compte le passage de l’unité de départ vers les coordonnées en pixels à l’écran).

Threadweaver rend l’écriture de code multithreadé plus facile en utilisant des tâches de fond. Contrairement à QThreadPool, il prend en compte les dépendances entre tâches, les signaux done (réalisé), ainsi que les signaux globaux jobsDone. Il permet aux fils d’exécution d’être suspendus et arrêtés facilement et ne dépend que de QtCore.

KConfig enregistre et restitue des paramètres de configuration. Il présente une API orientée groupe. Il utilise des fichiers INI et des répertoires/annuaires conformes à la norme XDG. Il génère du code en se basant sur les fichiers XML.

KItemModels contient (entre autres) :

  • un modèle de filtrage récursif pour les vues en arbre ;
  • un modèle de proxy vérifiable pour les arbres et les listes ;
  • et un second modèle de proxy, pour restructurer un arbre en liste.

KCoreAddons dispose des éléments suivants (entre autres) :

  • KJob : une classe de base pour faire des API asynchrones ;
  • file handling classes: directory watching, backup handling, auto save files ;
  • Partage des données en cache sur le disque entre applications ;
  • des classes de gestion de texte: séparer des chaines de caractères entre les mots et ajouter des points de suspension.
Cadriciels d’intégration

Ceux-ci ont des dépendances en fonction de la plateforme pour l’intégration système.

Sonnet a un correcteur orthographique d’arrière-plan, ainsi que des widgets et des dialogues de configuration. Il fonctionne via des extensions et peut fonctionner avec aspell, hspell, hunspell et enchant.

Solid peut détecter le matériel et informer une application sur les périphériques de stockage et les volumes, le CPU, le statut de la batterie, la gestion d’énergie, le statut de la connexion Internet et des interfaces réseau, et le Bluetooth. Pour les partitions chiffrées, l’énergie et le réseau, des démons en fonctionnement sont nécessaires.

Cadriciels solution

Ceux-là nécessitent que leurs propres démons fonctionnent correctement.

KIO permet à l’utilisateur de parcourir et modifier des fichiers indépendamment du fait qu’ils soient locaux ou distants. Il prend en charge un grand nombre de protocoles (incluant ftp, samba, webdav et nfs), de nombreux formats de fichiers compressés, les miniatures, l’extraction de la musique audio, la corbeille et fish, une vue de gestion de fichiers au travers d'une connexion ssh.

KService est un cadriciel qui fournit des fonctionnalités avancées de gestion des greffons, y compris la recherche sur le disque de ceux-ci à la demande. Il est utile pour les architectures à base de composants, où il permet de charger lors de l’exécution les dépendances nécessaires. Il offre également des fonctions pour trouver les applications associées à un type de fichiers, telles que l’identification de l’application préférée de l’utilisateur pour visualiser les PDF.

Migrer vers KF5

Il existe pas mal de ressources pour migrer sans douleur une application fondée sur les bibliothèques de KDE. On peut :

  • lire l’API ;
  • examiner les notes de portage ;
  • s’aider des projets déjà portés ;
  • obtenir de l’aide sur le canal IRC #kde-devel et la liste de diffusion kde-frameworks-devel@kde.org.

Il y a aussi un exemple de projet utilisant KF5.

CMake

A noter, l'adoption des idiomes de CMake : les macros kde4_* ne sont plus utilisées pour créer des cibles, mais les macros CMake, par exemple kde4_add_executable → add_executable. Attention aux dépendances : ${KDE4_KDEUI_LIBS} est remplacé par KF5::WidgetAddons. Notez que ça n’est plus une variable et que, si vous utilisez CMake 3.0, vous obtiendrez un avertissement si elle n’a pas été trouvée. De plus, il n’est plus nécessaire d’utiliser include_directories() pour chaque dépendance, ce sont maintenant les cibles qui s’occupent de ça. Jetez un œil à Extra-cmake-modules : il y a des choses intéressantes dont vous pourriez avoir besoin un jour, de plus c’est une extension CMake, vous pouvez l’utiliser même si Qt ou C++ n’est pas utilisé dans votre projet.

Laurent Montel, développeur KDE – notamment de KDEPIM – a développé des scripts pour faciliter la migration.

C++

Problablement la partie la plus facile, il suffit d’essayer de le faire compiler et de regarder l’API quand cela ne fonctionne pas, puis de recommencer.

Pour commencer le port, c’est en général mieux de s’appuyer sur le cadriciel KDELibs4Support au début. C’est un cadriciel qui contient tous les modules obsolètes, parce que ce sont des fonctionnalités qui ont été déplacées dans Qt5 pour la plupart. Ça aidera à avoir un projet qui compile et, ensuite, vous pouvez supprimer les dépendances obsolètes une par une.

Si vous souhaitez développer en Qt4 pour un moment encore, il peut être utile de faire quelques portages d’abord, par exemple la migration KIcon → QIcon::fromTheme, ce qui réduira la divergence entre la branche Qt4 et la branche Qt5. Ça peut aussi vous aider de faire des tests unitaires avant de migrer, pour éviter de tester toutes les fonctionnalités à la main pendant le portage.

QML

Porter du QML n’est pas trivial, mais il n’y a que quelques projets qui l’utilisent sérieusement. Toutes les technologies sous-jacentes ont changé, ça peut donc devenir épineux. Pour le moment, dans Qt5, il y a deux implémentations de QML. QtQuick 1, qui est celle que nous utilisions dans Qt4 et QtQuick 2 qui est celle que vous voulez utiliser, qui utilise le graphe de scène Qt (Qt Scene Graph) et qui fait de la magie avec le GPU.

Vous pouvez tout d’abord décider de rester en QtQuick 1. Néanmoins, PlasmaComponents a été porté à QtQuick 2, vous devrez donc faire le changement complet pour les plasmoïdes.

Si vous avez avez besoin de faire un port vers QtQuick 2, il y a aussi quelques scripts que vous pouvez utiliser pour faciliter la transition. Pour commencer, vous devez simplement renommer toutes les classes commençant par QDeclarative* vers QQml* et QQuick* ; elles gardent en général le même nom. Par contre, si vous utilisiez les fonctionnalités de QGraphicsView, vous vous êtes fait avoir !

Pour porter le code QML/Javascript vers QtQuick 2, il faut mettre à jour tous les imports. Tous les imports Qt sont montés de version, vous devez donc changer import QtQuick 1.1 pour import QtQuick 2.2, et — dans la même logique — remplacer import org.kde.plasma.components 0.1 par import org.kde.plasma.components 2.0.

Apports

Qt 5 apporte de nombreux nouveaux concepts intéressants, comme QtWebSockets, QtWayland, QtWebEngine ou Qt3D. De plus, cela permet à votre projet d’intégrer correctement le code Qt avec les nouveaux concepts de C++11.

Porter votre projet vers KF5 va l’aider à devenir plus portable et à cibler différentes plateformes.

Amélioration de l’outillage

Séparer les bibliothèques et faire en sorte que le système de compilation fonctionne a provoqué de nombreux cassage de compatibilité. Pour être sûr que tout fonctionne et obtenir des cadriciels compilables et fonctionnels, il était nécessaire d’avoir de meilleurs outils. Une énorme amélioration est l’arrivée d’un système d’intégration continue. Pousser du code pour un cadriciel signifie désormais qu’il est compilé dans un environnement propre et que des tests automatisés sont lancés. C’est aussi utilisé pour construire ses dépendances, donc les problèmes dans le code qui ont pu échapper à l’attention du développeur sont la plupart du temps détectés automatiquement. Les résultats du système d’intégration continue sont souvent disponibles après quelques minutes et, si quelque chose casse, les développeurs reçoivent des notifications sur IRC ou par courriel. Ces courts cycles permettent de résoudre les problèmes quand les modifications effectuées sont encore fraiches dans la tête du développeur. On gagne également du temps, car en récupérant le dernier code en développement, il y a moins de risque d’avoir un code qui ne compile pas.

La compilation déclenche aussi les tests automatisés, qui ont déjà été améliorées récemment, mais restent encore assez loin d’une couverture complète. Avoir des tests automatisés permet de trouver plus facilement les problèmes et améliore la confiance dans le fait qu’un changement particulier ne cause de désastre nulle part.

Ni les compilations continues, ni les tests automatisés ne permettent d’être à 100% sûr que quelque chose ne cassera pas un jour, mais c’est beaucoup moins probable et cela économise du travail aux développeurs. Si un script détecte un problème, c’est probablement beaucoup plus efficace que le test manuel (qui reste nécessaire, évidemment).

Un aspect social de cela est que si quelque chose casse dans les compilations ou tests automatisés, il n’y a pas qu'une seule personne qui est en charge du problème ; ça doit au contraire être un évènement où on « arrête la chaine » et nécessite une attention immédiate — de tout le monde.

Conclusion

La migration vers Qt5, la modularisation et l’amélioration du code des fondations est une avancée technique majeure dans l’histoire de KDE.

Mais les avancées ne sont pas uniquement techniques, l’organisation du projet s’améliore notamment avec plus de relecture de code, une meilleure organisation des dépôts et une unification du flux de travail avec notamment une migration vers GitLab.

La prochaine version de Plasma sera la première à utiliser KDE Frameworks 5 et cela promet d’être intéressant, car, là où le passage de KDE 3 à KDE 4 et de GNOME 2 à GNOME 3 ont été un gros changement de paradigme et technique, il n’est pas prévu de gros changements niveau utilisateur.

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

Encore une couche de rouille avec Rust 0.11

Linuxfr - lun, 14/07/2014 - 19:54

Rust 0.11 est sorti le 2 juillet 2014 ! Pour rappel, Rust est un langage de programmation système qui vise la performance et la sûreté. Il est développé par Mozilla, en parallèle d'un nouveau moteur de rendu expérimental écrit en Rust, Servo.

Rust est open source. Son développement est fait de façon ouverte sur GitHub et le code source est publié sous double licence Apache 2.0 et licence MIT.

Sommaire Rapide présentation de Rust Objectifs du langage

L’objectif de Rust est d’être un langage pour l’écriture de programmes systèmes, habituellement écrits en C++. Tout comme C++, Rust permet un contrôle explicite de la gestion de la mémoire et d’autres fonctionnalités du système d’exploitation et du matériel, pour écrire des programmes les plus efficaces possibles.

Rust diffère cependant de C++ en mettant l’accent sur la sûreté : grâce à un système de types fort et à l’intégration dans ce système de types de nombre d’idiomes de gestion de la mémoire (on y retrouve les sémantiques d’ownership, de move, mais également des concepts plus innovants comme l’analyse des lifetimes), le compilateur est capable de détecter à la compilation un très grand nombre d’erreurs qui en C++ auraient pu mener à des bugs, voire à des failles de sécurité potentielles.

En outre, Rust amène également au monde de la programmation système et impérative certaines fonctionnalités récentes issues de la programmation fonctionnelle : types algébriques, filtrage par motif (pattern matching), fermetures lexicales (closures), etc.

En bref, Rust se veut un remplaçant à C++ : moins complexe, plus sûr et plus moderne.

Rust étant développé au sein de Mozilla, on peut se demander s’il est prévu que Rust soit utilisé dans FirefoxOS, ce n’est pas encore le cas, bien que des essais aient été faits.

Exemple

Voilà un exemple d’une implémentation simpliste de ls :

use std::os; fn list_dir(path: &Path) { match std::io::fs::walk_dir(path) { // Le chemin donné par l’utilisateur n’est pas valide None => fail!("Unable to retrieve path: {}", path.display()), // Le chemin donné par l’utilisateur est valide, on liste les fichiers dedans Some(dir) => for file in dir { println!("{}", file.display()); } } } fn main() { // On récupère les arguments passé via la ligne de commande let argv = os::args(); // On vérifie que le nombre d’arguments donnés est bien conforme à ce qu’on attend. match argv.len() { // S’il n’y a pas d’argument, on utilise le répertoire courant comme répertoire à traiter 1 => list_dir(&os::getcwd()), // S’il y a un argument, on le considère comme répertoire à traiter. 2 => list_dir(&Path::new(argv[1])), // Sinon, on considère que l’utilisateur tape avec des moufles. _ => { println!("You must specify exactly zero or one path"); os::set_exit_status(1); } } } La communauté Rust

Rust est développé par Mozilla, qui emploie une équipe à plein temps pour travailler sur le langage, mais aussi par de très nombreux contributeurs : de 51 pour la version 0.1, 450 pour la 0.10 à 559 pour cette dernière version. Des statistiques plus détaillées sont disponibles sur le site RustStat.

Plusieurs moyens de communication existent sur Internet :

Rust a aussi des pages sur Google Plus et sur Facebook, ainsi qu’un mot-clé #rustlang, mais il n’y a pas d’activité particulière dans ces pages ; ce sont des rappels de Reddit.

On peut aussi remarquer que désormais LinuxFr.org fait partie de la mouvance avec sa propre étiquette rust ;) qui permet de retrouver facilement toutes les dépêches et tous les journaux abordant ce sujet.

Les échanges se font aussi directement lors d’évènemements.

Installation

Le tutoriel officiel détaille l’installation sur les différentes plateformes, cependant il faut aller dans le wiki pour avoir plus de détails.

Les procédures d’installation déjà en place pour la version 0.8 (pour Windows, Ubuntu, Arch Linux et Gentoo) décrites dans la dépêche ad hoc sont toujours valables et ont été mises à jour pour cette version. Dès l’annonce, les paquets pour Ubuntu ont été générés dans le PPA hansjorg/rust, une compilation pour Arch est disponible dans le dépôt community et pour Gentoo, l’overlay rust contient un ebuild pour cette version.

Voici rapidement les commandes à utiliser pour installer la dernière version :

# Sous tout type de Linux 64bits curl -O http://static.rust-lang.org/dist/rust-0.11.0-x86_64-unknown-linux-gnu.tar.gz tar xfz rust-0.11.0-x86_64-unknown-linux-gnu.tar.gz (cd rust-0.11.0-x86_64-unknown-linux-gnu/ && sudo ./install.sh) # Sous Arch, disponible dans les paquets officiels # Sous Gentoo sudo layman -a rust sudo emerge --autounmask =rust-0.11.0 # Sous Ubuntu sudo add-apt-repository ppa:hansjorg/rust sudo apt-get update sudo apt-get install rust-0.11

Pour Fedora, vous pouvez compiler en Rust en regardant ici ou .

Changements du langage

De nombreux changements de syntaxe, de sémantique, de bibliothèques sont advenus depuis la dernière version. Par exemple, le développeur de Angolmois a dénombré les changements qu’il a dû apporter à son code entre chaque version, depuis la 0.6. Moins de changements de code ont été nécessaires entre la 0.10 et la 0.11.

Syntaxe

Le symbole ~ a été remplacé par le type Box<T> pour dénoter les owned boxes, et par le mot-clé box pour l’allocation. De plus, les tableaux ~[T] et les chaines ~[str] ont été remplacées respectivement par Vec<T> et String. Comme il s’agit d’un changement très important et souvent mal compris par la communauté, voici une brève explication :

La précédente syntaxe causait de nombreuses confusions, du fait que ~[T] et ~str étaient en fait des structures particulières, et non pas de simple pointeurs ~ vers [T] ou str, ces derniers n’étant pas des types en Rust. Ceci menait à la bizarrerie syntaxique suivante :

// x est de type ~str, une chaîne allouée sur le tas, redimensionnable // du fait qu’elle possède la mémoire pointée // de même, y est de type ~[T], un vecteur redimensionnable alloué sur le tas let x = ~"foo"; let y = ~[1, 2, 3]; // x est de type ~(&'static str), un pointeur vers une zone allouée sur le // tas contenant un pointeur vers une chaîne statique // y est de type ~([T, .. 3]), un pointeur vers une zone allouée sur le tas // contenant un tableau statique à 3 éléments let x = ~("foo"); let y = ~([1, 2, 3]);

Les structures ~[T] et ~str étaient en fait des structures situées sur la pile, contenant 3 champs :

  • un pointeur vers une zone mémoire sur le tas ;
  • la taille de cette zone, ou « capacité » ;
  • et la partie de cette zone occupée par des données valides, soit la longueur de la chaine ou du tableau.

Ces structures implémentent des chaines et des tableaux dits « redimensionnables », car lors d’un ajout, si la capacité n’est plus suffisante, on met à jour le pointeur vers une zone plus grande, et on recopie depuis l’ancienne. Puisque ces structures possèdent leurs données et disposent de sémantiques de déplacement, personne ne possède de pointeur sur l’ancienne zone, qui peut alors être libérée en toute sûreté.

La sémantique de Rust étant devenue suffisamment puissante pour permettre d’exprimer ces propriétés sur des types tiers, ces structures ne nécessitent plus en aucun cas d’être intégrées au compilateur, et ont été déplacées vers la bibliothèque standard, sous les noms de String et de Vec<T>. On peut d’ailleurs noter que String n’est qu’une couche d’abstraction sur Vec<u8> fournissant des méthodes supplémentaires pour garantir que les données sont une chaîne UTF-8 valide.

De même, la syntaxe ~ pour représenter un simple pointeur vers le tas possédant la zone pointée (owned box, ou owning pointer), a été remplacée par Box<T> pour désigner le type et par l’expression box foo réalisant une allocation dynamique et renvoyant un Box<T>.

Cette syntaxe n’ayant plus rien en commun avec Stringet Vec, il n’y a plus de confusion possible. Si foo est de type T, box foo renverra toujours un Box<T> (équivalent de l’ancien ~T), de même que box (foo).

  • let x = box "foo"; // x est de type Box<&'static str>.
  • let x = box ("foo"); // pareil.
  • let x = box 5; // x est de type Box<int>.

Si l’on désire maintenant utiliser les chaînes et les tableaux redimensionnables, il faut être explicite et utiliser les noms String et Vec :

// la méthode from_str alloue une zone de mémoire suffisamment grande // et y recopie le contenu d’une autre chaine, ici une chaine statique // foo est de type String let foo = String::from_str("foo"); // from_slice alloue une zone de mémoire suffisamment grande et y recopie // le contenu d’un autre tableau, ici un tableau statique // bar est de type Vec<int> let bar = Vec::from_slice([1, 2, 3]); // on pourrait également utiliser cette version, équivalente, qui utilise // la macro vec!, fournissant une façon pratique d’initialiser des Vec let bar = vec!(1, 2, 3);

Cette nouvelle syntaxe montre bien que String et Vec sont en fait des structures sur la pile référençant une zone mémoire redimensionnable sur le tas.

Ces types sont munis d’un destructeur, ce qui garantit qu’ils disposent de déplacement (move semantics) et qu’ils possèdent les données pointées.

Ceci évite donc la confusion entre ces types et Box<T> qui n’ont rien à voir entre eux.

Par ailleurs, écrire let x = ~"foo" pouvait faire oublier au programmeur qu’il s’agissait d’une opération couteuse. On avait l’impression qu’il suffisait de prendre un pointeur sur une string, alors qu’il faut en fait allouer une zone sur le tas de la bonne taille, puis recopier la chaine. String::from_str est plus explicite, d’autant plus qu’elle est documentée, du fait qu’elle soit dans la bibliothèque standard et non une fonctionnalité intégrée au langage.

Enfin, bien que ~[] et ~str soient encore disponibles pour le moment, ils devraient être supprimés rapidement. Leur utilisation dans la base de code du compilateur et de la bibliothèque standard a déjà été pratiquement supprimée.

Notons que le pointeur @ qui a été placé derrière une feature gate (il devait être activé explicitement pour pouvoir être utilisé) lors de la sortie de rust 0.10 a été lui aussi été complètement supprimé.

Unboxed closures

Le système de fermetures (ou closures) de Rust a été complètement repensé.

Rust offrait actuellement deux types de fermetures : les stack closures et les « procédures ».

Les stack closures, qui capturaient les variables libres depuis leur environnement par référence. Ce type de fermetures était très utilisé dans du code Rust, mais du fait qu’elle ne possédaient pas leur environnement, elles n’étaient pas à proprement parler des valeurs de première classe. En particulier, il n’était possible de renvoyer une clôture sur la pile (stack closure) qu’à condition de la lier à une durée de vie (lifetime).

// la fonction get_adder prend un entier et renvoie une fermeture // additionnant cet entier (capturé) à un autre passé en argument fn get_adder(x: uint) -> (|uint| -> uint) { // on renvoie une fonction prenant y et renvoyant x + y // x est ici capturé par référence |y| { x + y } } fn main() { let add5 = get_adder(5); let r = add5(3); }

Ce code produisait une erreur du borrow-checker. Si ce code avait été exécuté, l’appel de add5 aurait tenté d’accéder à x via une référence pointant vers une zone mémoire qui n’est plus valide, x étant détruit à la fin de la fonction get_adder. On aurait pu paramétrer les types par des lifetimes et passer x à get_adder par référence, mais cela n’aurait pas totalement résolu le problème. Il n’aurait en aucun cas été possible d’utiliser add5 en dehors de la portée des variables capturées (ici, x).

Les « procédures » (notées proc), qui capturaient leur environnement par copie (en effectuant éventuellement un move). Ces fermetures étaient des valeurs de premier ordre, mais elles permettaient ensuite au code de la fermeture d’effectuer un move depuis les variables capturées au moment où la fermeture était exécutée. Ceci permettait à ces fermetures d’utiliser leur environnement de n’importe quelle façon, mais ne permettait de les appeler qu’une seule fois, car leur environnement était « consommé » par l’appel de la fermeture, du fait des moves possibles.

fn get_proc(x: uint) -> (proc(uint) -> uint) { proc(y) { x + y } // x a été capturé par valeur. Si x avait été // doté de move semantics, toute utilisation de // x ici aurait été une erreur car il aurait été // déplacé dans l’environnement de la fermeture } fn main() { let add5 = get_proc(5); let huit = add5(3); // erreur: l’appel de la procédure prend l’environnement par move // rustc détecte ici l’utilisation d’une valeur déplacée et émet // une erreur. Les procs ne sont donc appelables qu’une seule fois let neuf = add5(4); }

La proposition des unboxed closures rend le système de fermetures bien plus souple.

Toutes les fermetures captureront désormais leur environnement par copie. Les références étant des valeurs comme les autres en Rust, il sera toujours possible de capturer par référence en capturant explicitement une référence plutôt que la variable :

fn get_adder(x: uint) -> (|uint| -> uint) { // x est ici capturé par valeur (copie). Si x avait été // d’un type doté de sémantiques de déplacement, il n’aurait // plus été utilisable autrement que par la fermeture car // il aurait été déplacé vers son environnement, tout comme // dans l’exemple avec proc |y| { x + y } } // il est possible d’obtenir une capture par référence en capturant // explicitement une valeur dont le type est une référence. On fait // alors une copie de la référence // cet exemple reproduira le comportement précédent. La fermeture // est liée à la durée de vie de x fn get_adder_ref(x: uint) -> (|uint| -> uint) { // on crée explicitement une référence let ref_on_x = &x; // la fermeture capture une copie de la référence // et pas une copie de x |y| { *ref_on_x + y } }

Les unboxed closures seront implémentées comme des objets ayant chacun leur type unique contenant leur environnement. Pour refléter leur capacité à être invoquées comme des fonctions, elles devront maintenant implémenter un trait. Plusieurs traits seront introduits, pour représenter tous les cas possibles d’utilisation.

Tout d'abord, Fn : au moment de l’appel, le code reçoit son environnement via une référence mutable. La fermeture peut donc muter son environnement, mais ne peut pas effectuer de move depuis l’environnement. La fermeture est donc appelable plusieurs fois. Ce trait reflète les sémantiques d’appel des anciennes stack closures, tout en permettant de choisir au moment de la création de la fermeture si la copie se fait par copie ou par référence.

FnShared est similaire au précédent, à l’exception que la fermeture reçoit une référence immutable sur son environnement. Elle ne peut donc pas le modifier. L’avantage principal de ces fermetures est qu’elles peuvent être échangées de façon sûre entre différentes tâches s’exécutant de façon concurrente, d’où son nom.

Enfin, FnOnce implémente des sémantiques d’appel des anciennes procédures en passant à la fermeture son environnement par valeur. La fermeture peut alors librement effectuer des moves depuis l’environnement, qui est alors consommé. Une fermeture ne pourra être appelée qu’une seule fois via ce trait.

La syntaxe des fermetures ne sera donc plus que du sucre syntaxique sur la déclaration d’un type implémentant le trait approprié et la création d’une valeur unique de ce type. Mais il sera également possible de créer à la main de tels objets, et d’implémenter par exemple plusieurs comportements possibles. (à vérifier)

Le système de types de Rust ayant connaissance des sémantiques de déplacement, l’implémentation des unboxed closures ne requerra pratiquement aucune modification du système de types. Les règles actuelles garantissent déjà le comportement décrit ci-dessus en fonction de la façon dont l’environnement est passé au code de la fermeture lors de l’appel.

Bibliothèque standard

La bibliothèque standard a été découpée en plusieurs petites bibliothèques indépendantes. libcore, qui contient les fonctionnalités les plus basiques de la bibliothèque d’exécution (runtime library) du langage est ainsi autonome, et peut être utilisée dans des contextes tels que les systèmes d’exploitation ou la programmation embarquée.

Rust dispose maintenant d’une implémentation des expressions rationnelles, inspirée de RE2. Elle a été intégrée dans la distribution officielle en tant que libregex. libregex_macros fournit une extension de syntaxe, regex!, qui permet à rustc de compiler les expressions rationnelles en même temps que le reste du code.

En vrac, quelques autres modifications notables :

  • attention ! test::BenchHarness a été renommée en test::Bencher ;
  • la définition des vecteurs doit être plus précise : [1, 2] n’est plus acceptée, il faut spécifier le type, par exemple ainsi [1u, 2] ;
  • utilisation de Result<T, Error> dans les types de retour de l’interface Serialize ;
  • ajout d’une caisse GraphViz ;
  • réduction de la taille des exécutables ;
  • si vous vous demandez ce que Rust et Lovecraft on en commun, allez voir par ici ;
  • première bibliothèque stabilisée pour la version 1.0 : std::mem.
Autour du langage

Le code du dépôt Rust sur Github (compilateur, bibliothèque standard, tests unitaires et de performance ainsi que les tutoriels) a atteint les 30 000 commits le 25 juin. Voici un florilège des évènements notables :

Computer Language Benchmarks Game

Ce test de performance dont nous avions parlé dans la précédente dépêche sur Rust continue d’être mis à jour. Les sources des programmes de test sont en effet inclus dans les sources même de Rust (voir les fichiers shoutout-*). Les instructions SIMD sont ajoutées aux tests à l’aide du module std::unstable::simd, le test shootout-mandelbrot s’exécute ainsi presque deux fois plus vite.

Test × CPU secs Elapsed secs Memory KB Code B ≈ CPU Load Fasta 1.7 4.66 4.66 780 1283 0% - 1% - 1% - 100% Pidigits 7.2 12.48 12.49 1,708 677 0% - 1% - 0% - 100% Mandelbrot 10 52.22 52.23 780 633 1% - 100% - 0% - 0%

http://www.reddit.com/r/rust/comments/27dc75/what_happened_to_the_shootout_benchmarks/

Travis-CI

Les tests sur Travis-CI utilisant rust-nightly sont restés bloqués à la version du 18 avril. Travis-CI utilise Ubuntu Precise comme environnement et la construction automatique sur Launchpad s’est arrêtée car la version de gcc est trop ancienne. Le script configure de Rust ne prenait pas en charge la définition des variables d’environnement CC/CXX pour changer de version de compilateur. Des correctifs ont été proposés le 2 mai et intégrés depuis. La construction continue chez Launchpad a repris début juin.

Cargo

Cargo est le nouveau gestionnaire de paquets annoncé le 17 mars. Yehuda Katz et Carl Lerche réalisent son développement.

Le 21 juin, le gestionnaire n’est pas encore en version alpha mais permet de résoudre les dépendances et de les récupérer depuis Git. La version alpha est publiée le 23 juin en même temps que le site web associé pour sa documentation : crates.io. Un PPA pour Ubuntu est disponible à ppa:cmrx64/cargo, pour notamment pouvoir utiliser Cargo sur Travis-CI.

Servo

Servo est un projet expérimental de Mozilla visant à construire un moteur de navigateur Web pour la nouvelle génération d’appareils : téléphones portables, processeurs multicœurs et GPU haute-performance, en tirant parti de la sûreté de Rust, et de ses facilités pour exprimer la concurrence. Il est actuellement développé pour Mac OS X et Linux 64 bits. Il a récemment passé avec succès le test Acid2, comme planifié dans les objectifs du second trimestre.

Servo: Designing and Implementing a Parallel Browser.

Liens

Notes de version.

Récapitulatifs This Week in Rust

Si vous voulez suivre le mouvement de tout ce qui se passe à propos de Rust sans avoir à lire le détail des commits, des annonces sur la liste de diffusion, de Reddit ou de Twitter, le blog This Week in Rust fait une synthèse hebdomadaire des nouveautés et actualités autour de Rust :

Meeting Weekly

https://github.com/mozilla/rust/wiki/Meetings

Évènements

De nombreux évènements sont organisés autour de Rust. La rencontre parisienne se répète tous les 3es lundis du mois dans les locaux de Mozilla.

  • Paris, le 21 avril — Rust MeetUp ;
  • Londres, du 25 au 28 avril — Ludum Dare 29 ;
  • San Francisco, le 8 mai — Rust MeetUp : vidéos disponibles sur air.mozilla : Testing Rust and Fuzzing compilers de John Regehr, QuickCheck de Andrew Gallant et Testing Hackathon de Erick Tryzelaar ;
  • Paris, le 19 mai — Rust MeetUp, sur Servo ;
  • Pittsburgh, le 19 mai — Rust MeetUp : Code and Supply ;
  • Seattle, le 22 mai — Rust MeetUp  ;
  • Paris, le 16 juin — Rust MeetUp ;
  • San Francisco, le 10 juin — Dinnerup ;
  • Brooklyn, le 21 juin — Rust MeetUp ;
  • Pittsburgh, le 23 juin — Rust MeetUp : Code and Supply ;
  • Londres, le 26 juin — First Rust MeetUp in London : Awesome Rust, Servo: the parallel browser engine ;
  • San Francisco, le 26 juin — Rust Meetup, vidéos disponibles sur air.mozilla.org : Library Ecosystem for Rust Game Development, OpenGL and Rust, Voyager, Reducing VR latency with Rust ;
  • Lisbonne, le 2 juillet — Rust MeetUp : Goals and crash course through the tutorial ;
  • San Francisco, juillet — Rust Meetup : WebTech ;
  • Seattle, le 7 juillet — Rust MeetUp ;
  • Hanovre, le 10 juillet — Rust MeetUp ;
  • Paris, le 21 juillet — Rust MeetUp ;
Présentations

Il y aura peut-être bientôt des cours de Programmation Fonctionnelle Système en Rust à Mozilla Paris.

Tutoriels et documentation Projets Nouveaux projets Conclusion

La liste des améliorations pour cette version de Rust n’est pas bien longue: modification des types Vectors, et les Strings en préparation des types à taille dynamique (DST), la suppression de ~ et continuation du découpage de la bibliothèque standard de Rust. Tout cela a nécessité beaucoup de travail de fond, et c’est le signe que Rust gagne en maturité.

Côté communauté, on a des développeurs payés par Mozilla et Samsung qui travaillent sur Rust et Servo, des dizaines de nouveaux projets, la prise en charge de Rust dans de plus en plus de logiciels et d’environnements, et une présence sur le web toujours plus importante, Rust semble promis à un bel avenir.

Télécharger ce contenu au format Epub

Lire les commentaires

Catégories: Nouvelles du Libre

ERP : où en sont les entreprises ?

Toolinux - dim, 13/07/2014 - 23:34

L'éditeur Sage vient de publier une infographie illustrant les résultats d'une étude réalisée par le CXP sur l'équipement et les usages des ERP en entreprises.

- Services
Catégories: Nouvelles du Libre
Syndiquer le contenu