Report on the Designing Accountable Software Systems Workshop
Soutenu par la National Science Foundation des États-Unis, l'atelier de novembre 2024 sur la conception de systèmes logiciels responsables (DASS) a réuni des parties prenantes interdisciplinaires pour explorer les dimensions, les cadres juridiques et les défis opérationnels de la responsabilité logicielle, identifiant finalement des directions de recherche clés pour clarifier les responsabilités, améliorer l'intégration de la responsabilité dans la conception de logiciels et répondre aux exigences uniques de la collaboration transdisciplinaire.
Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète
Imaginez que vous soyez en train de construire une ville robotique géante et complexe. Dans cette ville, des logiciels gèrent les feux de signalisation, gèrent les comptes bancaires, décident qui obtient un prêt et conduisent même les voitures. Les gens qui vivent dans cette ville (la société) et les personnes qui ont écrit les règles (le gouvernement) attendent que la ville robotique respecte la loi et agisse de manière équitable.
Mais voici le problème : le logiciel ne sait pas naturellement comment être « responsable ». Il se contente de faire ce qu'on lui dit. Si une erreur est commise, à qui la faute ? Au codeur ? À l'entreprise ? À la loi ?
Ce document est un rapport sur une grande réunion (un atelier) où des experts en informatique, en droit, en sociologie et en gestion se sont réunis fin 2024 pour comprendre comment construire des logiciels capables de répondre de leurs actes. Considérez cela comme un « sommet d'architectes, d'avocats et d'urbanistes » tentant de concevoir un nouveau ensemble de plans pour une ville robotique responsable.
Voici ce qu'ils ont découvert, expliqué simplement :
1. Le problème de la « Boîte Noire »
Actuellement, lorsqu'un logiciel enfreint les règles, c'est souvent comme une boîte noire. Nous voyons le mauvais résultat, mais nous ne savons pas comment cela s'est produit ni pourquoi.
- L'analogie : Imaginez un chef qui vous sert une soupe empoisonnée. Si le chef se contente de dire : « L'ordinateur m'a dit de mélanger ces ingrédients », cela ne suffit pas. Nous avons besoin d'un « enregistreur de vol » (comme dans un avion) à l'intérieur du logiciel qui enregistre chaque étape franchie, afin que nous puissions prouver ce qui s'est passé et qui est responsable.
- La conclusion : Le groupe a convenu que nous devons concevoir des logiciels qui tiennent automatiquement un journal de leurs actions « infalsifiable ». Mais ils ont également noté que nous ne pouvons pas tout enregistrer (cela générerait trop de données) ; nous devons enregistrer les bonnes choses.
2. La barrière de la langue
Le plus grand obstacle n'est pas la technologie, mais le fait que les experts parlent des langues différentes.
- L'analogie : Imaginez un avocat et un ingénieur logiciel essayant de construire un pont. L'avocat parle de « responsabilité civile » et de « conformité », tandis que l'ingénieur parle d'« algorithmes » et de « latence ». Ils utilisent les mêmes mots (comme « équitable » ou « risque »), mais ils ne veulent pas dire la même chose.
- La conclusion : Les chercheurs ont constaté que lorsque ces groupes travaillent ensemble, ils font émerger des idées brillantes. Cependant, il faut du temps pour apprendre le vocabulaire de l'autre. Parfois, ils finissent même par écrire des articles dans des revues différentes que personne d'autre ne lit, ce qui rend difficile le partage des connaissances.
3. Le piège du « Symbolique »
Parfois, les entreprises prétendent être responsables sans l'être réellement.
- L'analogie : C'est comme un magasin qui affiche un panneau « Nous nous soucions de la sécurité » en vitrine, mais qui, en coulisses, rogne sur les coûts pour économiser de l'argent. Ils ont l'air corrects sur le papier (le « symbole »), mais la réalité est différente.
- La conclusion : Le groupe a averti que nous devons cesser de regarder uniquement les « panneaux » (les rapports d'audit) et commencer à regarder la machinerie réelle. Nous avons besoin d'outils capables de faire la distinction entre une entreprise qui dit suivre les règles et une qui les suit réellement.
4. La cible mouvante (IA et changement)
Le logiciel, en particulier l'IA, change constamment. Il apprend et s'adapte.
- L'analogie : Les règles de sécurité traditionnelles sont comme un livre de recettes : « Si vous ajoutez du sel, la soupe sera salée ». Mais l'IA est comme un chef qui goûte la soupe et décide d'ajouter du poivre, puis du sucre, puis du vinaigre, de lui-même. Les anciennes règles ne fonctionnent plus car le chef modifie la recette pendant la cuisson.
- La conclusion : Nous avons besoin de nouvelles façons de vérifier si ce logiciel « apprenant » respecte toujours les règles. Si le logiciel change d'avis, comment savoir s'il n'a pas enfreint une loi dans le processus ?
5. Le puzzle du « Qui est responsable ? »
Quand les choses tournent mal, il est souvent difficile de désigner le coupable.
- L'analogie : Si une voiture autonome percute un piéton, est-ce la faute de la voiture ? Du fabricant de cartes ? De la personne qui a acheté la voiture ? De la ville qui a construit la route ?
- La conclusion : Le groupe a réalisé que nous devons définir clairement qui est responsable avant de construire le logiciel. Le logiciel est-il responsable devant la loi ? Devant le public ? Devant l'entreprise ? Ils ont constaté que sans définitions claires, la responsabilité tombe dans les failles.
6. Le monde « Parfait » vs le monde « Réel »
Le groupe a admis que nous ne pouvons pas construire un logiciel parfait qui ne commet jamais d'erreurs.
- L'analogie : Vous ne pouvez pas construire une voiture qui ne crash jamais, mais vous pouvez construire une voiture qui possède des airbags et des ceintures de sécurité pour gérer les accidents quand ils surviennent.
- La conclusion : Au lieu d'essayer de créer un logiciel qui ne faillit jamais, nous devrions le concevoir pour qu'il admette quand il est confus, pour qu'il laisse l'humain intervenir, et pour qu'il ait un plan lorsque les choses tournent mal. Nous devons accepter que l'« imperfection » fait partie du système, mais nous devons en gérer les conséquences.
L'essentiel
Le point principal de cette réunion est que vous ne pouvez pas résoudre le problème du logiciel responsable avec seulement du code.
Cela nécessite un effort collectif. Vous avez besoin des informaticiens pour construire les outils, des juristes pour écrire les règles, des sociologues pour comprendre comment les gens réagissent et des chefs d'entreprise pour faire en sorte que cela se concrétise. Si nous essayons de faire cela en silos (séparément), nous échouerons. L'avenir du logiciel dépend de ces différents groupes apprenant à parler la même langue et construisant des systèmes qui ne se contentent pas de fonctionner, mais qui fonctionnent correctement.
Noyé(e) sous les articles dans votre domaine ?
Recevez des digests quotidiens des articles les plus récents correspondant à vos mots-clés de recherche — avec des résumés techniques, dans votre langue.