Qt a des principes assez stricts en ce qui concerne la compatibilité entre versions : par exemple, si une application fonctionne parfaitement avec Qt 5.0.0, elle continuera à fonctionner avec Qt 5.0.1 sans recompilation (aux défauts corrigés près) et vice-versa : c’est une compatibilité tant ascendante que descendante.

Au contraire, les versions mineures (Qt 5.1, 5.2, etc.) ne garantissent qu’une compatibilité ascendante : si une application est compilée avec Qt 5.0, elle fonctionnera avec Qt 5.1 sans nécessiter de recompilation de l’application — une compatibilité descendante serait ici impossible, car de nouvelles fonctionnalités font leur apparition d’une version à l’autre. Par contre, une version majeure peut casser cette compatibilité : pour passer de Qt 4 à 5, il a été nécessaire de recompiler toutes les applications et d’en retoucher légèrement les sources. Toutefois, les modules d’extension de Qt ne sont pas sujets aux mêmes garanties.

Ces garanties facilitent la vie des distributeurs de logiciels, particulièrement pour les distributions Linux : une version partagée de Qt suffit pour tout le système, elle peut être mise à jour indépendamment des applications — ce qui limite fortement l’utilisation de bande passante pour les mises à jour, économise de l’espace disque et permet la correction de défauts rapidement.

Un casse-tête pour les développeurs…

Pour atteindre ces objectifs, les développeurs de Qt doivent faire attention à deux points : les compatibilités au niveau des sources et des binaires. La première est relativement simple : l’interface de programmation doit rester identique d’une version à l’autre, les ajouts étant autorisés ; par conséquent, une fonction ne peut pas changer de prototype (un nouveau paramètre ne peut pas devenir obligatoire d’une version à l’autre). Par le principe d’encapsulation, une classe peut être réimplémentée complètement sans casser cette compatibilité des sources.

Par contre, la compatibilité binaire est plus épineuse : elle est atteinte quand un programme qui lie dynamiquement une version plus ancienne de Qt peut être utilisée avec de nouvelles versions de Qt sans recompilation de l’application. Alors qu’il est souvent bénin d’ajouter des fonctions sans casser la compatibilité binaire, il est impossible de changer la taille d’un objet en mémoire, car cela casserait les mécanismes d’allocation dynamique. Ces modifications doivent alors être planifiées pour la prochaine version majeure, où la recompilation sera nécessaire. De même, rendre une fonction constante change le nom du symbole associé, c’est-à-dire que le système d’exploitation ne la trouvera plus dans la bibliothèque partagée.

… et pour les distributions Linux

La compatibilité binaire facilite fortement la maintenance d’une distribution Linux, mais il faut s’assurer qu’elle est bien respectée. Pour ce faire, Fedora s’est dotée d’un nouvel outil : ABI Tracker. Il remplace le Linux Upstream Tracker, qui n’est plus mis à jour.

Ainsi, les mainteneurs de la distribution peuvent réagir pour chaque non-respect de la compatibilité binaire et décider de mettre à jour telle ou telle bibliothèque : ils peuvent prédire la quantité de dysfonctionnements à attendre de cette opération. Il peut s’agir d’un comportement erratique du programme (par exemple, un symbole de plus dans une énumération : les tests sur la valeur peuvent alors échouer), voire d’un plantage pur et simple lorsque l’exécution passe à un point donné du programme (un symbole n’existe plus). Par exemple, le module Qt Core a eu tous ces problèmes en passant de la version 5.1.1 à 5.2.0, selon l’outil de Fedora.

Qt respecte-t-il ses principes de compatibilité ?

En regardant la page montrant l’évolution de Qt, une chose saute à l’Å“il : la garantie de compatibilité binaire est loin d’être respectée depuis Qt 4.7 (sorti fin 2010), sauf pour les dernières versions correctives de Qt 4.8.

Ce constat mérite néanmoins d’être nuancé. Pour Qt 5.0, le score de zéro pour cent est totalement justifié, étant donné que c’était l’objectif du changement de version majeure. Pour Qt 5.6, la prochaine version avec support à long terme, le score est catastrophique, avec moins de nonante pour cent au lieu des cent promis ; en regardant le détail, on se rend compte qu’une bonne partie est due à une erreur d’empaquetage, Qt 3D étant inclus dans le rapport précédent, alors que ce module est loin d’être finalisé ; d’autres modules ont été supprimés et n’aident pas le score.

Plus en détail, pour le module Qt Quick, qui n’atteint qu’un score de 92,3 %, une bonne partie des symboles supprimés correspond à une classe qui n’a jamais fait partie de l’API publique (DesignerSupport). Le tiers restant correspond néanmoins aux destructeurs de classes publiques. A contrario, les dernières versions correctives de Qt 4.8 ne posent strictement aucun souci.

Bien évidemment, cette vision est partielle, parce qu’elle est obtenue avec un outil générique, qui ne prend pas en compte certaines spécificités de Qt (les API privées). Il n’empêche que certaines modifications semblent casser cette compatibilité, sans qu’elles ne posent de problème spécifique aux mainteneurs.

Sources : Qt Version Compatibility, Future of the Linux upstream tracker.

Voir aussi : Pensées sur la compatibilité binaire et sur les conventions d’appel.

GammaRay est un outil de débogage et d’introspection développé spécifiquement pour les applications Qt. Contrairement aux débogueurs classiques (GDB, LLDB ou autres, intégrés ou non aux environnements de développement intégrés), il comprend Qt et son mécanisme de fonctionnement, avec les connexions de signaux et slots, la hiérarchie des objets. Il donne donc, de manière générale, une vue de plus haut niveau du comportement de l’application, en comprenant parfaitement la structure de composants de Qt comme les QGraphicsView ou le graphe de scène Qt Quick — là où un débogueur traditionnel ne peut se placer qu’au niveau de l’instruction machine, avec parfois des extensions pour Qt, notamment pour afficher correctement la valeur de certaines variables, ce qui devient plus délicat encore pour le code généré par le moc.

Un deuxième gros avantage de GammaRay est son aspect visuel : il est capable de générer une visualisation de parties complètes de l’application pour en faciliter le débogage, plus particulièrement quand les éléments s’imbriquent l’un dans l’autre. Par exemple, il peut afficher les machines d’état et leur évolution, le contenu des modèles, les liens complexes entre signaux et slots : au lieu d’aller rechercher ces éléments disparates au fond des structures de données de Qt, il les rassemble tous dans une vue unique.

De plus, il ne fait pas que lire les objets : il peut aussi les modifier, en utilisant les facilités offertes par QObject. En effet, malgré toute la puissance du langage et l’importance de son écosystème, Qt utilise du C++ et a toujours besoin d’un étape de compilation, que ce système permet d’éviter pour une série de cas lors d’une séance de débogage intensif dans une application complexe. Ainsi, un développeur peut modifier une bonne partie du comportement de l’application à l’exécution, tout comme les développeurs Web exploitent les outils offerts par les navigateurs modernes — qu’elle soit basée sur Qt Quick, Qt Widgets, QGraphicsView… ou toute combinaison des trois !

La version 2.4.0 arrive très bientôt et apporte pas mal d’améliorations côté Qt Quick, notamment les propriétés attachées et la navigation dans les items. Pour les propriétés de type composite, l’éditeur peut maintenant agir en mode récursif. La gestion des erreurs et avertissements gérés par la classe QMessageLogger (ce qui inclut notamment les fonctions qDebug, qCritical, etc.) a été retravaillée, principalement au niveau de la liste des fonctions dans la pile au moment de l’appel.

Voir aussi les sources : site officiel, dépôt GitHub.

Qt 5.6 sera une version charnière dans l’histoire de Qt, mais pas vraiment au niveau des fonctionnalités : un support à long terme est prévu pour les trois prochaines années, tout comme ce fut le cas pour Qt 4.8.

Nouvelles fonctionnalités par rapport à Qt 5.5

La première préversion a apporté pas mal de nouveautés, notamment pour Qt 3D et diverses préversions technologiques (les nouveaux Qt Quick Controls, l’accès aux bus série par Qt SerialBus, la reconnaissance vocale et la synthèse vocale avec Qt Speech, la compatibilité avec le compositeur Wayland par Qt Wayland), ainsi que des améliorations de performance.

Cette nouvelle préversion, Qt 5.6 Beta, apporte une meilleure gestion des écrans à haute résolution sur toutes les plateformes, avec un ajustement automatique des tailles de police et des autres éléments d’interface, y compris quand l’utilisateur déplace une fenêtre sur un autre écran avec une densité de pixels différente.

La compatibilité avec Windows 10 est maintenant parachevée, tant pour les applications traditionnelles que WinRT, ces dernières pouvant être distribuées sur le Windows Store — grâce à Qt, la migration se fait en un coup de compilation. Visual C++ 2015 fait maintenant partie de la liste des compilateurs compatibles ; par contre, l’extension pour Visual Studio n’est pas compatible avec la version 2015.

Support à long terme

Le point le plus important de cette version est cependant son support à long terme (LTS), disponible pendant trois ans. La précédente version dans ce cas était Qt 4.8, sortie début 2013, dont le support s’achève ce mois-ci — Qt 5.6 devrait être disponible au premier trimestre 2016, ce qui laissera quelques semaines sans version à support à long terme. Après trois ans, comme pour Qt 4.8, il faudra souscrire un contrat d’extension de support auprès de Digia.

Ce « support à long terme » signifie que Qt 5.6 aura droit à des correctifs, tant pour la sécurité que pour la correction de défauts ou la compatibilité avec de nouveaux systèmes d’exploitation et des compilateurs plus récents autant que possible ; en d’autres termes, Qt 5.6 aura droit à une série de versions de patch, au lieu d’une à deux pour les autres versions mineures de Qt 5. Sur le côté, Qt continuera bien évidemment à évoluer, avec de nouvelles fonctionnalités dans les versions mineures ultérieures (Qt 5.7 et suivantes), mais elles ne seront pas réintégrées dans Qt 5.6, afin de garantir qu’une application utilisant Qt 5.6 continue à fonctionner après une mise à jour de Qt, sans grand risque.

Objectif : faciliter le développement ultérieur

Globalement, ce support à long terme permettra de simplifier le code pour Qt 5.7, après une phase de développements pour mettre les différentes plateformes sur un pied d’égalité au niveau des fonctionnalités offertes pour Qt 5.5 et 5.6. Ces simplifications pour Qt 5.7 se feront parfois au détriment de fonctionnalités et de couches de compatibilité dépassées.

Les modules désapprouvés ne font pas partie de cette offre de support à long terme, ils devraient être rapidement supprimés. Cette liste contient Qt Script et Qt Enginio — sachant que Qt WebKit et Qt Declarative ne sont plus livrés dès cette version, remplacés respectivement par Qt WebEngine et Qt Quick 2, par suite de la décision de les désapprouver pour Qt 5.5.

De même, les préversions technologiques ne sont pas incluses, aucune garantie n’est fournie à leur égard : Qt 3D n’a toujours pas atteint un niveau de finition suffisan, à l’instar de Qt Quick Controls 2.0, de Qt Speech, de Qt SerialBus ou de Qt Wayland. Pour les compilateurs, Qt 5.6 sera la dernière version à maintenir la compatibilité avec C++98 et de vieux compilateurs, comme Visual C++ 2008 et 2010 ou encore GCC 4.6.

Sources : Qt 5.6 Beta Released, Introducing Long Term Support.

Quelques mois après la version 0.9, la nouvelle version de LXQt est sortie, avec le numéro 0.10. Cet environnement de bureau léger pour Linux basé sur Qt continue à gagner en maturité, avec de nombreuses améliorations ergonomiques et nouvelles traductions.

Les panneaux ont été l’objet de nombreux travaux. Ils peuvent maintenant se cacher automatiquement pour libérer de la place à l’écran, grouper plusieurs icônes d’une même application, en plus de gérer le glisser-déposer d’icônes. Le gestionnaire de fichiers PCManFM a vu sa fonctionnalité de recherche s’améliorer ; il peut aussi être contrôlé avec les boutons avancer-reculer de certaines souris.

La partie principale du travail a cependant porté sur l’amélioration de la qualité du code de l’environnement. Notamment, la version précédente a commencé à utiliser les KDE Frameworks, des bibliothèques généralistes issues de l’environnement KDE ; celle-ci exploite désormais Solid, la couche orientée matériel, qui détecte notamment les nouveaux périphériques branchés, sans dépendance explicite envers le système d’exploitation. De même, libkscreen remplace l’utilisation de xrandr pour la configuration du serveur X, tout en étant compatible avec Wayland ; en passant, l’interface a été complètement repensée. L’élévation de privilèges est désormais gérée par le module lxqt-sudo, à travers les commandes lxsu et lxsudo.

Sources : LXQt 0.10 Released!, [ANN] LXQt 0.10 released!.

Merci à Claude Leloup pour ses corrections.

Une bonne année après l’annonce de la première préversion d’Inqlude, un total de cent quatre-vingts-quatre paquets est maintenant répertorié sur la base de données. Notamment, tous les modules de KDE Frameworks sont disponibles dans leur dernière version.

Cette collection est gérée en ligne, dans un dépôt GitHub. Pour tout ajout ou mise à jour, il suffit d’y envoyer une demande de modification. Elle est directement utilisée par tous les clients Inqlude : le site, mais aussi le client C++. Le site propose également une version plus réduite, ne contenant que la dernière version de la description de chaque bibliothèque (et non chaque modification, comme le dépôt Git).

Actuellement à la version 0.7.2, le client en ligne de commande peut lister les paquets disponibles et installés, ainsi qu’installer une bibliothèque. Dans le futur, une plus forte intégration avec le reste de l’écosystème Qt est prévue, comme avec l’installateur ou encore Qt Creator ; plus de métadonnées sur les paquets sont aussi prévues, comme le niveau de maturité ou encore l’activité du développement (un indicateur qui devrait être automatisé).

Source : 184 Qt Libraries.

Cutelyst est une brique logicielle basée sur Qt et fournissant des fonctionnalités facilitant le développement Web, en utilisant donc le langage C++. Son avantage principal est la possibilité de partager du code avec des applications natives et mobiles, particulièrement si elles sont développées avec Qt (ou au moins en C++). Son développement a débuté fin 2013 et a directement montré que Catalyst avait de meilleures performances, tant en utilisation de mémoire que de temps jusqu’au premier octet envoyé au client, une caractéristique partagée par beaucoup de frameworks Web C++.

Cette nouvelle version apporte la gestion des vues JSON, très utiles pour développer des API. Cette fonctionnalité est fortement intégrée avec la classe QJson de Qt, pour en faciliter l’utilisation et exploiter le code existant.

Le module Cutelyst::Core a été séparé en plusieurs parties : il ne contient plus que les fondations de la bibliothèque, c’est-à-dire les parties Context, Request et Response et leurs dépendances. Par exemple, la gestion des sessions est maintenant disponible dans une extension, Cutelyst::Plugin::Session, qui ne fait plus doublon pour ceux qui préfèrent utiliser leur propre implémentation. De même, les actions ne sont plus intégrées d’office, elles sont maintenant chargées au besoin.

La prochaine version, numérotée 0.11, devrait exiger Qt 5.5 (au lieu de Qt 5.4 actuellement), mais aussi apporter une manière déclarative (au sens de QML) pour définir les applications.

Source : Cutelyst 0.10.0 released!

Qt 5.6 vient de sortir en préversion Alpha. Les nouveautés s’égrainent le long des divers modules, avec un grand nombre d’optimisations, notamment au niveau de la mémoire utilisée. Elles sont en grande partie dues à l’utilisation d’analyse statique du code proposée par Clang : utiliser un profileur pour toutes les exécutions possibles dans le code prendrait trop de temps pour un gain trop faible ; par contre, un analyseur statique peut passer sur tout le code et faire remarquer tous les endroits à améliorer. Il est donc très utile quand le problème de performance n’est pas localisé, mais bien réparti sur tout le code. Ce genre d’outil a une compréhension plus fine du C++ qu’un compilateur : là où le compilateur s’arrête à la syntaxe, l’analyseur statique tente de comprendre la sémantique du code (ce qu’il tente de faire) et propose de meilleures manières de l’écrire. Par exemple, un algorithme de la STL pourrait fonctionner plus vite en allouant à l’avance de la mémoire avec std::vector::reserve() ; il pourrait même réécrire automatiquement le code pour suivre les meilleures pratiques concernant QStringLiteral et QLatin1String.

Qt 3D n’est toujours pas finalisé, mais les fonctionnalités de la préversion technologique s’affinent : de nouvelles API pour les tampons et attributs, pour les entrées souris, pour la détection de collisions ; la gestion de l’instanciation, le chargement de scènes glTF (avec un outil pour les compiler : qgltf). De nouveaux exemples ont également été ajoutés.

Dans les modules, quelques changements ont eu lieu. Notamment, des modules désapprouvés par Qt 5.5 ont été supprimés (Qt WebKit et Qt Declarative, qui correspond à Qt Quick 1). De nouveaux modules sont maintenant déconseillés : Qt Script (remplacé par le moteur JavaScript V4, inclus dans Qt QML) et Qt Enginio ; ils pourraient être supprimés dans une prochaine version de Qt. De nouveaux modules font également leur apparition en tant que préversions technologiques : Qt Quick Controls 2.0, des contrôles plus légers, prévus plus particulièrement pour l’embarqué ; Qt Speech pour la reconnaissance vocale, en faisant appel aux API disponibles sur chaque système (le module est actuellement compatible avec Android, OS X et Windows) ; Qt SerialBus, pour faciliter l’accès aux nombreux bus série qui peuplent le monde de l’embarqué, actuellement compatible uniquement avec CAN ; Qt Wayland, avec une API pour le compositeur Wayland stabilisée.

Cependant, la principale avancée concerne les outils utilisés pour le développement de Qt lui-même : l’ancien moteur d’intégration continue, Jenkins, a été remplacé par un nouveau, Coin, développé exclusivement pour Qt (qui pourrait d’ailleurs être distribué sous licence propriétaire ou libre dans le futur). Ainsi, chaque modification apportée au code source de Qt est compilée (voire testée) sur vingt-cinq à trente plateformes, ce qui assure une plus grande stabilité du code.

Sources : Qt 5.6 Alpha released, How to use static analysis to improve performance, New Features in Qt 5.6.

La première préversion de Qt Creator 3.5 est maintenant disponible. L’amélioration la plus graphique concerne la barre de défilement vertical, qui indique maintenant tous les signets, les points d’arrêts et les résultats de recherche.

L’analyse du code C++ par Clang a été repensé, avec notamment le déplacement de l’exécution dans un autre processus que Qt Creator (ce qui le met à l’écart de tout problème à l’exécution de Clang). Les binaires ont également été mis à jour pour utiliser Clang 3.6.

Certaines fonctionnalités de Qt Creator ont également été retirées : Qt Quick Designer ne pourra plus éditer de fichiers de l’époque Qt Quick 1 ; les assistants Qt Quick 1 ne sont plus disponibles ; le profilage du code JavaScript avec V8 n’est plus possible. Par contre, toutes les fonctionnalités concernant Qt Quick 2 (ainsi que l’éditeur de code pour Qt Quick 1) sont conservées. Toujours au chapitre des suppressions, Qt Creator n’est plus compatible avec la plateforme Blackberry 10, par manque de mainteneur — QNX, le système d’exploitation en temps réel sous Blackberry 10, principalement utilisé dans l’embarqué, reste d’actualité.

D’autres modifications plus légères ont également été apportées. Pour la gestion d’Android, des corrections de défauts ont eu lieu pour Android M et les éditions 64 bits. Sur OS X, Spotlight est désormais accessible pour la recherche de fichiers.

Source : Qt Creator 3.5 beta1 released

Qt 5.5 inclut une première préversion technologique du module Qt 3D, un framework de haut niveau qui facilite l’ajout de contenu 3D dans des applications Qt, écrites tant en QML qu’en C++. Son statut actuel montre que le module n’est pas encore mature : son API peut continuer à évoluer, plus de fonctionnalités seront ajoutées avant la première version stable.

Qt 3D fournit un grand nombre de fonctionnalités nécessaires pour le rendu 3D actuel, tout en profitant de la performance d’OpenGL sur toutes les plateformes (sauf iOS pour le moment, qui devrait être prochainement disponible). Ce module propose également de modifier l’apparence des objets affichés à l’écran, soit en utilisant des matériaux prédéfinis, soit en créant ses propres shaders. De plus, il donne un contrôle sur le rendu de la scène 3D à l’aide d’une description orientée données. Il est donc possible de créer rapidement des prototypes d’algorithmes de rendu. L’intégration à Qt Quick 2 se fait par le composant Scene3D.

Cette première préversion contient d’ores et déjà un grand nombre de fonctionnalités :

• un système à entités flexible et extensible, prévu pour le parallélisme ;
• le chargement de géométries, en utilisant le module d’import OBJ ou assimp s’il est disponible ;
• un système de passes de rendu pour les matériaux et les effets pour adapter l’apparence aux besoins ;
• une configuration par les données : il est possible de changer la manière dont le rendu est effectué sans toucher à une ligne de C++ ;
• un grand nombre de techniques de rendu déjà implémentées : rendu non différé, avec une profondeur, un affichage différé ou d’objets transparents, etc. ;
• une compatibilité avec tous les types de shaders (sauf les compute shaders) ;
• une compatibilité avec les UBO (uniform buffer objects) s’ils sont disponibles ;
• des fonctions simples pour les primitives géométriques de base et les matériaux ;
• un contrôle de la caméra par la souris ;
• une intégration aisée dans des interfaces Qt Quick 2.

Au-delà du rendu, Qt 3D fournit également un environnement propice à l’ajout de nouvelles fonctionnalités, comme les simulations physiques, l’animation de squelettes, l’audio 3D, le rendu stéréoscopique, l’intelligence artificielle ou d’autres mécanismes d’entrée.

L’article Aperçu de Qt 3D 2.0 donne plus de détails sur l’organisation et les possibilités de Qt 3D.

Source : Qt3D 2.0 Technology Preview.

Qt 5.2 a apporté le module Bluetooth, initialement très limité : il n’était utilisable que sur Linux par BlueZ 4 et sur BlackBerry 10. Chaque version a amélioré l’état du module : avec Qt 5.3, il devient compatible avec Android ; avec Qt 5.4, il devient compatible avec BlueZ 5 sous Linux et la version basse énergie Bluetooth LE (pour Low Energy) est accessible (uniquement pour BlueZ, en préversion). Avec Qt 5.5, il devrait être compatible avec OS X (y compris la variante LE), WinRT (ARM) pour la 5.6.

L’objectif principal de ce module est de fournir une couche d’abstraction des fonctionnalités Bluetooth de base, utilisable peu importe la plateforme : chercher des périphériques Bluetooth accessibles, leur envoyer des données par OPP (object push profile), s’y connecter par un canal RFCOMM en série (SPP, serial port profile), etc. La déclinaison LE devient de plus importante, dans Qt mais aussi dans ses applications : avec l’habitronique, les divers capteurs connectés, tant pour la santé que l’environnement, les périphériques doivent limiter au maximum leur consommation ; Qt reste utile pour ces applications, grâce à ses fonctionnalités Bluetooth LE.

De nouvelles fonctionnalités sont prévues pour les prochaines versions de Qt : une compatibilité avec Windows (x86), des interfaces Qt Quick, des améliorations pour la détection et la communication des fonctionnalités disponibles, par exemple pour l’interaction avec des périphériques iBeacon (Apple).

Source : Qt Bluetooth and its state of the union, QTBUG-31674.