Orbitiny est un bureau Linux portable qui se lance comme une appli et qui ne joue pas dans la même catégorie.

Un bureau qui tourne au-dessus d’un autre, et ce n’est pas une blague

Dans l’écosystème des environnements de bureau Linux, on connaît les approches classiques, un gestionnaire de fenêtres, un compositeur, un panel, un menu, des services de session. Orbitiny arrive avec une idée qui semble contre nature, un bureau complet qui se lance comme une simple application, au-dessus de votre environnement actuel, sans remplacer quoi que ce soit, sans ouvrir une nouvelle session, sans toucher à votre configuration.

On clique, et un deuxième bureau apparaît, avec son propre panel, son propre menu, son propre gestionnaire de fichiers, comme une couche graphique autonome qui s’empile sur la première. C’est inhabituel, mais ça fonctionne.

Comment ça marche réellement, sous le capot

Orbitiny n’utilise pas KWin, Mutter ou Openbox. Il embarque son propre mini gestionnaire de fenêtres, écrit en Qt et C++, qui ne prend pas le contrôle de la session. Le système hôte continue de gérer les vraies fenêtres, les notifications, les entrées clavier et souris. Orbitiny ne gère que ce qu’il crée lui-même.

Techniquement, Orbitiny est une application Qt géante, un conteneur qui simule un bureau, un panel, un menu, un gestionnaire de fichiers et des services internes. Cela lui permet de tourner au-dessus de KDE, GNOME, Xfce ou n’importe quoi d’autre, sans conflit de compositeur, sans guerre de raccourcis clavier, sans écraser les paramètres de session.

C’est cette encapsulation qui rend possible le mode portable et l’exécution parallèle.

Qu’est-ce que ça apporte que les autres bureaux n’apportent pas

Orbitiny ne cherche pas à remplacer KDE ou GNOME. Il propose autre chose, un bureau autonome, portable, encapsulé, qui peut être lancé n’importe où, sans installation, sans dépendances lourdes, sans interaction profonde avec le système.

Ce que cela change concrètement :

1. un bureau que l’on transporte réellement sur une clé USB, avec ses réglages et ses plugins
2. un environnement isolé pour tester des applications sans polluer son bureau principal
3. un espace de travail temporaire pour les techniciens, les formateurs, les utilisateurs nomades
4. une solution pour les distributions live qui veulent proposer un bureau complet sans l’intégrer au système
5. une manière de contourner les limitations d’un bureau hôte sans le modifier

Orbitiny n’est pas un remplaçant, c’est un bureau parallèle, un bac-à-sable/sandbox graphique.

Des fonctionnalités déjà bien avancées

Le gestionnaire de fichiers maison, Qutiny, propose des fonctions rarement vues ailleurs, fusion de fichiers texte par glisser déposer, fusion d’images verticalement, recherche par nom et par contenu, double panneau, gestion des opérations avec emblèmes visuels. Ce sont des fonctions immédiatement utiles, sans installer d’outils externes.

Le bureau gère les gestes souris, jusqu’à douze par bouton, gauche ou droit. On peut dessiner un cercle pour ouvrir un terminal, une ligne pour lancer un navigateur, un zigzag pour fermer une fenêtre interne. C’est rapide, efficace, et entièrement configurable.

Chaque écran physique peut avoir son propre fond d’écran, ses propres raccourcis, ses propres applets. Chaque bureau virtuel peut également avoir sa propre configuration. Cela permet de créer des espaces de travail réellement indépendants.

Orbitiny détecte automatiquement WINE et DOSBox. On peut lancer un .exe Windows ou un programme DOS directement depuis le bureau ou le gestionnaire de fichiers, sans créer de fichier .desktop ou de configuration manuelle.

Le mode portable, la vraie différence

L’archive fait environ 185 Mo. On la décompresse sur une clé USB, on lance start-orbitiny, et tout fonctionne immédiatement. Tous les réglages sont stockés dans le dossier d’extraction. On peut donc transporter son bureau complet, ses préférences, ses plugins, et les retrouver sur n’importe quelle machine Linux.

Pour les techniciens, c’est un bureau de secours.
Pour les utilisateurs avancés, c’est un environnement jetable.
Pour les curieux, c’est un terrain d’expérimentation sans risque.
Pour les distributions live, c’est un bureau plug and play.

Informations concrètes

Orbitiny est sous licence GPLv3. Le code source et les binaires sont disponibles sur SourceForge. Le projet est développé par Sasko Usinov. Les premières versions datent de 2023, la version actuelle est la 0.3.0.

Orbitiny utilise Qt 5 et Qt 6 selon les modules, du C++ moderne, et une architecture modulaire composée de 48 composants isolés. Si un composant plante, le reste du bureau continue de fonctionner. C’est un choix technique rare dans les environnements de bureau.

Le développement est actif, et les prochaines étapes annoncées concernent l’amélioration du système de plugins, un thème sombre complet et la stabilisation du mode portable.

Premières impressions, un projet jeune mais déjà solide

Orbitiny tourne vite, tourne bien, tourne même très bien pour un bureau qui s’empile sur un autre. Le gestionnaire de fichiers accède directement au système hôte, le panneau de configuration est déjà complet, l’ensemble est fluide et cohérent.

On est loin du prototype bricolé un dimanche soir. Orbitiny ressemble à un projet avec une vision claire, et surtout avec une approche technique différente de ce que l’on voit habituellement.

Un concept étrange mais une idée qui mérite d’exister

Orbitiny ne remplacera pas KDE ou GNOME, mais ce n’est pas son but. Il propose une approche différente, un bureau autonome, portable, encapsulé, qui peut cohabiter avec n’importe quel environnement existant. Rien que pour ça, il mérite d’être essayé.

Il y a exactement deux mois, un incident était survenu suite à un redémarrage brutal du serveur hébergeant les conteneurs de production et de développement ayant entraîné une attribution inattendue d’adresses IP. Et des réponses techniques 502 Bad Gateway pour notre lectorat.

Ce 26 août, vers 15:22, un message peu engageant est arrivé par pneumatique sur nos téléscripteurs (via Signal pour être précis) : « Tiens c’est bizarre j’ai perdu accès au site. Et au serveur oups. » L’après-midi et la soirée furent longues.

Sommaire

• • Premier diagnostic
  • Eh bien des requêtes habituelles…
  • La boucle sans fin
  • Une dernière page d’epub ?
  • Retour en graphiques sur la journée
  • Mesures préventives et correctives
  • Bonus inattendu pour l’incident précédent du 26 juin 2025

Premier diagnostic

Le serveur répond au ping et permet les connexions TCP port 22, mais pas le SSH. Et les services web ne répondent plus. Souci matériel ? Noyau en vrac ? Attaque en cours ? Les spéculations vont bon train.

La connexion au serveur revient par intermittence, permettant à un moment d’exécuter quelques commandes, à d’autres d’attendre longuement pour l’affichage d’un caractère ou l’exécution de la commande tapée.

Le premier contact réétabli avec le serveur est assez clair (une forte charge) :

$ uptime
15:06:59 up 2 days,  2:54,  1 user,  load average: 50,00, 205,21, 260,83

(dernier redémarrage le week-end précédent, mais surtout une charge système moyenne respectivement de 50, 205 et 261 sur les 1, 5 et 15 dernières minutes)

Initialement on suppose qu’il s’agit d’un trop grand nombre de requêtes ou de certaines requêtes tentant des injections de code sur le site (bref le trafic de fond plutôt habituel et permanent), et on ajoute des règles de filtrage péniblement et lentement pour bloquer les IP qui ressortent le plus dans nos logs.

Le site est alors inaccessible pendant plusieurs périodes. On arrête et relance ensuite plusieurs fois les services en pensant avoir ajouté suffisamment de filtrage, mais rapidement le serveur se retrouve englué. Les services sont alors arrêtés plus longuement le temps d’analyser les logs au calme. Au calme inclut notamment ne pas juste disposer d’une connexion ssh depuis un smartphone, mais plutôt d’un clavier et d’un grand écran par exemple, de l’accès à tous les secrets et toute la documentation aussi.

Finalement le trafic n’est pas énorme (en volume total) et si les requêtes hostiles sont bien présentes, rien ne semble inhabituel. Par contre les processus de coloration syntaxique partent en vrille, consommant chacun un processeur et aspirant allègrement la mémoire disponible. Avant d’être éliminés par le noyau Linux.

La console est remplie d’élimination de processus de ce type :

Mais si rien n’a changé niveau logiciel sur le conteneur LXC de production et si les requêtes ne sont pas inhabituelles, qu’est-ce qui peut bien écrouler le serveur et créer ces processus gourmands ?

Eh bien des requêtes habituelles…

Pendant les phases d’attente lorsque le serveur ne répondait plus vraiment, nous avons noté qu'une nouvelle entrée de suivi a été créée (merci BAud et merci RSS/Atom pour nous avoir permis de la voir alors que le serveur ne répondait déjà plus). Elle indique que la coloration syntaxique ne marche plus sur le site. Notamment l’exemple donné dans la documentation.

Pourtant le rendu fonctionne en testant en ligne de commande avec pygmentize.

Mais oui en testant l’exemple donné via le site, il est créé un processus Python2 pygment qui commence à se gaver de ressources.

Et en regardant les différents contenus et commentaires créés sur le site autour de l’incident, en filtrant sur ceux contenant des blocs avec de la coloration syntaxique, la dépêche (alors en préparation) sur G'MIC 3.6 apparaît. Et en testant cette dépêche, il est bien créé quatre processus Python2 pygment qui se gavent de ressources et ne semblent jamais vouloir se terminer. À rapprocher par exemple d’une page qui a été servie en 6785.9978s.

OK, le souci vient de requêtes tout à fait habituelles de coloration syntaxique, reste à comprendre pourquoi ces processus tournent mal.

La boucle sans fin

Un petit strace pour suivre les appels système en cours sur un des processus infernaux relève une boucle assez violente :

(...)
close(623199355)                        = -1 EBADF (Bad file descriptor)
close(623199356)                        = -1 EBADF (Bad file descriptor)
close(623199357)                        = -1 EBADF (Bad file descriptor)
(...)

Il semble y avoir une immense itération sur des descripteurs de fichiers, en vue de les fermer, mais à l’aveugle, sans savoir s’ils existent réellement.

En regardant le code du composant utilisé (pygments), il semble n'y avoir qu'un seul appel à close() :

# close fd's inherited from the ruby parent
        import resource
        maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1]
        if maxfd == resource.RLIM_INFINITY:
            maxfd = 65536

        for fd in range(3, maxfd):
            try:
                os.close(fd)
            except:
                pass

Donc on itère sur tous les descripteurs entre 3 et le maximum déterminé…

>>> import resource
>>> print(resource.getrlimit(resource.RLIMIT_NOFILE)[1])
524288
>>> print(resource.RLIM_INFINITY)
-1

Un demi-million de fois ici donc. L’objectif initial de la boucle est de fermer les descripteurs de fichiers provenant du processus Ruby père, issue du fork via Open3.popen3. La version suivante du composant la remplace d’ailleurs par un ajout de l'option :close_others, qui précisément « modifie l’héritage [des descripteurs de fichiers du processus parent] en fermant les non-standards (numéros 3 et plus grands) ».

Sur une Debian 12, la limite du nombre de fichiers par défaut, c’est 1 048 576. C’est déjà probablement bien plus que la valeur qui prévalait à l’époque où a été écrit la boucle Python (on avait des limitations à 4096 à une époque reculée). Mais il s’avère que durant le week-end l’hôte du conteneur de production a été migré en Debian 13. Sans modification du conteneur de production pensions-nous. Sans modification directe du conteneur de production. Mais quid d’une modification indirecte ? Par exemple si la limite par défaut des « Max open files » était passée à 1 073 741 816 sur l’hôte, soit 1024 fois plus que quelques jours auparavant. Et donc des boucles nettement plus longues voire sans fin, sans libération de mémoire.

On ne peut mettre à jour le composant pygments dans l’immédiat, mais on peut limiter les dégâts en abaissant la limite du nombre de descripteurs de fichiers à quelque chose de raisonnable (i.e. on va gaspiller raisonnablement des cycles CPU dans une boucle un peu inutile mais brève…). Une édition de /etc/security/limits.conf, un redémarrage du conteneur de production et on peut vérifier que cela va nettement mieux avec cette réparation de fortune.

Une dernière page d’epub ?

Le conteneur LXC portant le service epub de production a assez mal pris la surcharge du serveur, et vers 20h08, systemd-networkd sifflera la fin de la récré avec un eth0: The interface entered the failed state frequently, refusing to reconfigure it automatically (quelque chose comme « ça n’arrête pas d’échouer, débrouillez-vous sans moi »). Le service epub est resté en carafe jusqu’au 27 août vers 13h31 (merci pour l’entrée de suivi).

Voir ce commentaire sur la dépêche de l’incident précédent expliquant la séparation du service epub et du conteneur principal de production (en bref : dette technique et migration en cours).

Retour en graphiques sur la journée

Le serveur était très occupé. Au point de n’avoir pas le temps de mettre à jour les graphiques de temps en temps.

Rétrospectivement les processeurs du serveur ont travaillé dur : 140 de charge sur le graphique (mais avec des pics jusque 260 d’après la commande uptime), contre moins de 5 en temps normal (un petit facteur de 28 à 52   ô_Ô)

Et l’utilisation de la mémoire montre aussi de brutaux changements de comportement : libération intempestive de mémoire (Free, en vert), utilisation mémoire plus importante que d’habitude (Used, en jaune), là où le comportement normal est d’avoir le maximum en cache (Cached, en orange) et des processus tellement peu consommateurs en RAM que cela n’apparaît normalement pas.

Mesures préventives et correctives

Dans les actions en cours ou à prévoir :

• mettre à jour la documentation pour disposer facilement et rapidement des informations pour les connexions aux cartes d’administration ou les procédures de blocages d’IP
• procéder à la montée de version des composants (yapuka, épineux sujet de la dette technique à éponger)
• vérifier l’efficacité des limitations CPU/mémoire mises sur certains conteneurs LXC et les étendre aux autres
• mettre des limites sur des processus particuliers (comme ceux de pygments)
• ajouter le déploiement des limites par utilisateur dans le code Ansible
• corriger la collecte rrd des métriques concernant les interfaces réseau
• remonter les alertes OOM qui ne sont pas normales
• comprendre la surconsommation mémoire ? (les boucles actives expliquent la consommation processeur, mais pour la mémoire ?)

Bonus inattendu pour l’incident précédent du 26 juin 2025

De façon cocasse, ce nouvel incident et le temps passé à parcourir les différents logs ont permis de retrouver les infos de la carte d’administration distante et d’expliciter l’origine du redémarrage serveur intempestif. À quelque chose malheur est bon, si on peut dire. Ceci n’est pas une invitation pour un prochain incident.

Pour ce deuxième épisode consacré aux transports, direction le ferroviaire.

Nous découvrons Open Source Railway Designer (OSRD), un outil de simulation du réseau ferroviaire développé au sein de SNCF Réseau. Son objectif ? Produire des données utiles à la planification des travaux d’infrastructure et faciliter l’attribution de sillons de dernière minute pour le fret.

Avec Céline Durupt, Yohan Durand et Loïc Hamelin, nous abordons plusieurs aspects du projet :

• Présentation d’OSRD et de son fonctionnement
• Genèse du projet et contexte de développement chez SNCF Réseau
• Accès aux algorithmes et aux données
• Données nécessaires, disponibles et obligations de publication
• Financement et modèle économique d’OSRD
• Création de l’association OpenRail
• Forme juridique et choix d’une association belge
• Gouvernance d’OpenRail et d’OSRD

Bonne écoute ! 🎧

Invitation de la 1ʳᵉ session technique sur l’Open Networking animé par Ouest Network : jeudi 26 septembre 2024 18h00 à Rennes (Siège d’Icodia).

• 18h00 : Ouverture / Accueil des participants, moment d’échange convivial

• 18h45 : Introduction Antoine Nivard Président Ouest Network

• 19h00 : Témoignage d’Icodia : l’OpenNetworking en datacenter

• 19h30 : Présentation de support OpenNetworking par l'intégrateur Pine Networks

• 20h00 : Témoignage d’Icodia : présentation d’EndiGuard.VAC, solution de VAC algorithmique

• 20h30 : Présentation de Ruijie Networks / Micas Networks et de leurs solutions réseaux Open Networking (SONiC).

• 21h00 : Conclusion Antoine Nivard Président Ouest Network

• 21h05 : Apéritif dînatoire / échanges

• 22h00 : Clôture

L’objectif de la soirée
Faire découvrir l’approche et la solution OpenNetworking est production et démontrer que cette solution est prête pour toutes les entreprises.

L’Open Networking, c’est quoi : c’est d’abord séparer le matériel du logiciel/firmware. Cela veut dire que le matériel est « banalisé », standardisé.
Pour la partie logiciel/firmware, vous avez le choix entre plusieurs « distributions » selon vos besoins. Vous pouvez aller assez loin via des fonctions de Software Defined Network (SDN).
C’est le Libre pour le réseau !

Ouest Network c’est quoi : c’est une association a but lucratif qui gère le point d’échange de Nantes et qui gère cet événement. Nous regroupons une quinzaine de structures et nous sommes reliés au point d’échange de Rennes/Bretagne : Breizh-IX qui est partenaire de l’opération.

Icodia est un gros hébergeur rennais qui a des compétences particulières et qui utilisent principalement que des solutions « Libres ».

NdM  : les événements à portée locale et/ou sans diffusion en ligne ont vocation à être annoncés par l'Agenda du Libre (AdL), que nous relayons une fois par semaine. Cet événement n’étant pas actuellement déclaré dans l’AdL d’une part, et étant le premier sur un sujet qui n’est pas si fréquemment évoqué sur LinuxFr.org, la modération a choisi de diffuser l’annonce en dépêche. On aimerait bien plus de dépêches portant sur OpenDaylight, Open vSwitch, Sylva, etc.

L’informatisation et la mise en réseau des ordinateurs nous ont apporté beaucoup de choses formidables ces trente dernières années. Toute la culture musicale, cinématographique et encyclopédique est désormais à une portée de clic de quiconque. Téléphoner de n’importe où à n’importe qui tout autour de la terre est devenu quelque chose de tellement courant que plus personne ne s’en extasie. Et même si l’interlocuteurice s’exprime dans une autre langue ça n’est presque plus un problème avec les différents services de traduction en ligne que l’on peut avoir.

Ne parlons même pas de ce mini-ordinateur que presque tout le monde a désormais dans sa poche, équipé d’une chaîne hifi complète, d’un caméscope, d’un appareil photo d’excellente qualité et d’une connexion permanente au réseau mondial.

Nos logements sont désormais entièrement automatisables et pilotables à distance.

Je peux avoir de la musique ou la radio quand je veux dans mon casque sans fil grâce à la baladodiffusion.

Tous ces rêves numériques des années 90 se sont concrètement réalisés aujourd’hui, mais nous avons tout de même perdu quelque chose : le temps réel des interfaces

N. D. M. : par « temps réel » est ici utilisé dans le sens réponse immédiate humainement parlant, sans latence perceptible, réactives (voir les définitions Wiktionary ou Wikipedia pour temps réel qui, pour l’informatique, vont amener des exigences supplémentaires sur la durée maximale de réponse, la garantie du temps de réponse, etc.

Sommaire

• Le temps réel des interfaces
• Les systèmes sont devenus mous
• Revenons aux interfaces réactives
• Manifeste des interfaces temps réel
• Vers un Score-Interfaces-Temps-Réel ?
• Conclusion

Le temps réel des interfaces

En effet, avec la diffusion du numérique à tous les étages, les interfaces se sont ramollies. Aujourd’hui, lorsque nous appuyons sur un bouton pour jouer une musique, lancer une vidéo ou valider un formulaire sur Internet nous n’avons pas un retour immédiat de cet appui.

Il s’écoule souvent un temps non négligeable entre l’appui sur ledit bouton et la réaction du système. Ce problème ne se limite pas aux boutons bien sûr, c’est le même problème avec les branchements des chargeurs et autres interfaces USB, HDMI…

Nous ne sommes jamais immédiatement sûrs que l’action se soit bien passée. Si la réaction met trop de temps à venir (lancement de la musique, icône de mise en charge, validation du formulaire…) nous allons avoir tendance à réessayer au risque de se retrouver avec un « dys »fonctionnement anormal. Le bouton « play » de la musique est également le bouton pause, un ré-appui sur le bouton coupe la musique. Une absence de réaction de l’appareil au branchement va nous amener à débrancher puis rebrancher jusqu’à jeter le câble et en prendre un autre. Un ré-appui sur le bouton du formulaire va en renvoyer un autre, etc.

Nous parlons bien ici des interfaces qui ne sont pas en temps réel. Cela n’a rien à voir avec la puissance de calcul des machines. Les appareils des années 90 avaient beau avoir des interfaces temps réel, ils n’étaient pas puissants, beaucoup ne disposaient même pas de microprocesseurs.

Sur mon lecteur de cassettes audio, lorsque j’appuyais sur le bouton « play » le bouton émettait un « clic » bien distinctif et une petite vibration dans le doigt qui m’assurait que mon appui était bien pris en compte. Et si j’étais à la fin de la cassette le bouton remontait immédiatement, je savais instantanément que cela n’avait pas marché et qu’il fallait que j’appuie sur « eject » pour retourner la cassette… ou « rewind » pour rembobiner.

Pour lire ma cassette de petit ours brun, j’appuie sur le triangle et ça fait «clic» instantanément !

Alors que pour allumer la boite à histoires, il faut appuyer sur un bouton planqué sur le côté, et attendre plusieurs secondes que l’écran affiche un sourire. Ai-je bien appuyé ? Dois-je retenter ? Y a-t-il suffisamment de batterie pour que j’obtienne une réaction ? Et je ne parle même pas des deux boutons rotatifs rouge qui ne réagissent pas instantanément (en plus celui de gauche est à tourner pour le volume et celui de droite est à CLIQUER pour changer d’histoire…)

Les télévisions cathodiques des années 70-80 prenaient un certain temps à chauffer avant d’afficher l’image, mais l’appui sur le bouton « on » était marqué par un « clang » bien net, et nous savions que la télé était allumée, nous pouvions attendre d’avoir l’image. Les télés d’aujourd’hui mettent également du temps à s’allumer, mais elles ne signalent pas toujours la bonne réception de notre action sur la télécommande. Et ne parlons même pas des écrans d’ordinateur avec leur interface tactile à la noix (on doit pouvoir parler d'interfaces digitales pour le coup non ?) dont on ne voit même pas où se trouve le bouton.

Les systèmes sont devenus mous

Et cette mollesse les rend dysfonctionnels. Je ne compte plus le nombre de fois ou voulant ré-appuyer sur un bouton de validation, j’ai finalement appuyé sur un nouveau bouton venant d’apparaître sous mon doigt/curseur. Sans parler de tous ces systèmes électroniques portables qui prennent un temps dingue avant d’afficher quelque chose quand on appuie sur le bouton “ON”. Systèmes qui ne sont pas toujours réellement éteints d’ailleurs et dont l’appui long… les éteint !
Ne parlons même pas des systèmes avec boutons rotatifs de type « potards numériques » qui — non contents de générer des rebonds ou de sauter des pas — fonctionnent avec la même mollesse que les boutons « standard ».

Mais le problème ne se limite pas aux systèmes embarqués. Oh que non ! Toute l’informatique « desktop » et mobile est touchée. Les sites Web ont rouillé avec leurs méga-octets de bibliothèques javascript à télécharger avant de pouvoir appuyer sur le moindre bouton.

Le réseau étant désormais massivement sans fil (WiFi, GSM, 4g, 5g, gégé, …), l’on ne sait pas toujours pourquoi cette page met tant de temps à se charger. Attention, il n’est pas question ici de vitesse de connexion, mais plutôt d’absence d’indication claire de ce qui est en train de se passer : ai-je déconnecté, ou le lien réseau est-il tout simplement lent ?

Revenons aux interfaces réactives

C’est un problème d’ergonomie. Et l’ergonomie est visiblement toujours reléguée en fin de projet «tant qu’on a un truc qui marche». Cependant, on pourrait considérer que non, ça ne marche pas si l’interface est si lente à réagir.

Je suis persuadé que ce problème n’est pas une fatalité. Il est possible de revenir à des interfaces humain-machine qui soient vraiment temps réel.

Mais il faut que tout le monde s’y mette.

• Aux électroniciennes et électroniciens de mettre systématiquement le voyant (ou vibreur, ou son) qui va bien pour signaler le bon branchement du câble, et le bon appui sur le bouton.
• Aux développeuses et développeurs noyau de soigner l’ordonnanceur pour s’assurer que la partie interface soit bien traitée dans un temps acceptable (moins de 100 ms ?).
• Aux développeuses et développeurs d’applis de considérer un temps de réaction trop long des interfaces comme un bug qu’il faut corriger.
• Aux utilisatrices et utilisateurs de ne plus accepter un seul ralentissement de l’interface et remonter systématiquement le problème comme un bug et/ou ne pas acheter/utiliser le produit.

Manifeste des interfaces temps réel

Voici donc une proposition/un manifeste de règles pour des interfaces temps réel :

1. Toute action humaine (appui ou clic-toucher sur un bouton, branchement d’un câble…) doit être validée par un retour en moins de 100 ms par un visuel, un son ou une vibration.
2. Si le système est bloqué l’utilisateurice doit le savoir. On doit pouvoir faire la différence entre un blocage et un temps de chargement. Un genre de watchdog de l’ergonomie.
3. On peut certainement ajouter d’autres règles quand on fera des audits ITR (Interfaces Temps Réels) dans les bureaux d’études et de développement des grosses boites.

Vers un Score-Interfaces-Temps-Réel ?

Évidement, il est impossible que ces règles s’appliquent du jour au lendemain sur tous les appareils et logiciel du marché. On pourrait inventer un système de notation, à l’image du nutri-score mais pour les interfaces. Par exemple le SITR pour Score-Interfaces-Temps-Réel et développer une appli pour pouvoir récupérer le score des produits qu’on utilise.
Appli qui aurait le culot d’avoir un mauvais score histoire de faire causer.

Conclusion

Pour conclure sur ce manifeste décousu :

✊🏼 Oui l’ergonomie est importante !
✊🏽 Oui un temps de réaction trop long est un BUG !
✊🏿 Oui il faut que ça change !

Après une ouverture en septembre 2016 et huit promotions, la licence professionnelle ADSILLH (Administrateur et Développeur de Systèmes Informatiques à base de Logiciels Libres et Hybrides) ouvre de nouveau ses portes à l’Université de Bordeaux à la rentrée 2024 !

Cette licence professionnelle vise à former les étudiants à intégrer des logiciels libres en un ensemble cohérent répondant aux besoins des entreprises, un système d’information complet par exemple, en interopérant au besoin avec des logiciels propriétaires (hybridation). Il s’agit également de s’impliquer dans les communautés de développeurs de logiciels libres, pour remonter ou corriger les bogues, contribuer des fonctionnalités (c’est tout l’objet du projet tutoré).

C’est une licence pro en un an (donc BAC + 3), elle est ouverte aux L2, DUT/BUT2, BTS, en formation initiale et en alternance, mais aussi en formation continue, reprise d’études et contrat professionnel (on peut faire une VAP — Validation des Acquis Professionnels — pour l’inscription). Des VAE (Validation des Acquis de l’Expérience) sont également possibles.

Contenu

• systèmes et réseaux :
  • programmation système,
  • programmation réseau,
  • installation et configuration des systèmes et réseaux ;
• technologies logicielles :
  • bases de données,
  • développement Web,
  • logiciels de communication ;
• progiciels CMS/ERP/BI ;
• sûreté et sécurité ;
• projet tutoré : contribution à un logiciel libre ;
• droit et économie des logiciels libres ;
• anglais ;
• stage en entreprise.

Prérequis

Les prérequis sont l’utilisation d’Unix en général, la programmation de base en Python et en C et une touche d’algorithmie. Il est possible de s’auto‑former sur les éventuels quelques éléments manquants entre l’inscription et la rentrée. Le détail est disponible sur le site de la formation.