Les hommes viennent de Mars. Les femmes viennent de Vénus. Les ordinateurs viennent de l'Enfer.
Enfin, c'est le cas lorsque votre système plante soudainement, emportant avec lui une heure de travail non sauvegardée. Mais ça ne doit pas être comme ça. Certains ordinateurs peuvent tourner pendant des années avant de subir un redémarrage. Malheureusement peu de ces ordinateurs sont des PC.
Si des mainframes, des gros serveurs, des systèmes de contrôle intégrés peuvent fonctionner pendant des années sans planter, geler, ou refuser de fonctionner, alors pourquoi pas les PC ? Étonnamment, la réponse ne provient que partiellement de la technologie. La plus importante raison pour laquelle les PC d'aujourd'hui sont les ordinateurs les plus enclins à planter jamais construits, c'est que la fiabilité n'a jamais été une priorité -- que ce soit pour l'industrie ou pour l'utilisateur.
«Lorsqu'un mainframe de 2000 utilisateurs plante, vous n'avez pas uniquement à redémarrer et poursuivre le travail,» déclare Stephen Rochford, un consultant expérimenté de Colorado Springs au Colorado, qui développe des applications financières sur mesure. «Le client demande pourquoi le système a planté et il veut que le problème se règle. La plupart des clients possédant des PC ne posent ces questions.»
Heureusement, certains signes montrent que tous prêtent une plus grande attention à ce problème. Les utilisateurs s'impatientent devant les plantages qui leur font perdre beaucoup de temps -- sans mentionner les réparations complexes qui consomment encore plus de temps -- mais ce n'est qu'un élément dans la balance.
C'est pourquoi l'industrie du PC travaille sur des solutions qui devraient réduire les plantages. On commence à voir des systèmes d'exploitation qui se mettent à jour eux-mêmes, des applications qui se réparent elles-mêmes, des outils de développement qui aident les programmeurs à écrire du code plus propre, et un intérêt renouvelé dans les technologies qui ont subi l'épreuve du temps et qu'on retrouve dans les mainframes et les systèmes intégrés. En prime, certaines de ces améliorations rendront les PC plus faciles à gérer.
Mais ne sautez pas de joie -- ce n'est guère qu'une révolution. Le changement s'installe lentement et les PC demeureront les ordinateurs les moins fiables pour des années encore.
Avant d'examiner les raisons techniques du plantage des PC, il est utile d'analyser la psychologie des PC -- de loin la raison la plus évidente de leur mauvaise conduite. Voici les faits : les PC sont nés pour être mauvais.
«Le concept fondamental de l'ordinateur personnel fut de faire des compromis qui garantissaient que les PC planteraient plus souvent,» déclare Brian Croll, directeur de marketing de Solaris chez Sun Microsystems. «Le premier PC a fait des compromis qui ont horrifié les informaticiens de cette époque, mais l'idée était de fabriquer un ordinateur qui était plus abordable et plus petit. L'ingénierie est l'art de faire des compromis.»
Ce n'est pas que les pionniers du PC n'étaient pas intéressés à la fiabilité. C'est seulement parce qu'ils étaient plus intéressés à réduire la taille de l'ordinateur de sorte que tous pouvaient en posséder un. Ils se sont servis des composantes les moins dispendieuses dans leur quincaillerie et ils ont pris des raccourcis périlleux en écrivant le logiciel.
Par exemple, pour tirer le plus de performance d'un CPU lent et de quelques kilo-octets de RAM, les premiers PC exécutaient l'application, le système d'exploitation et les pilotes de périphérique dans un même espace d'adressage de la mémoire principale. Un seul bogue dans l'une ou l'autre de ces composantes était suffisant pour mettre le système à genoux. Les développeurs de systèmes d'exploitation n'avaient pas vraiment le choix, parce que les premiers CPU n'avaient pas le concept de mémoire protégée ou d'un mode Kernel isolant le système d'exploitation des autres programmes tournant en mode utilisateur. Tous les logiciels s'exécutaient dans un espace d'adressage partagé et non protégé, où n'importe qui peut démolir l'autre, faisant planter le système.
Ironiquement, cependant, les premiers PC étaient passablement fiables, remercions leur grande simplicité. Dans les années 70 et début 80, les plantages de système n'étaient pas aussi courants qu'aujourd'hui. (C'est difficile à prouver, mais tous jurent que c'est la vérité). Les vrais problèmes ont commencé lorsque les PC sont devenus plus complexes.
Prenez comme exemple la croissance phénoménale de la taille d'un système d'exploitation moderne pour PC : Windows NT. La version originale de 1992 renfermait 4 millions de lignes de code -- ce qui était considéré comme beaucoup à l'époque. NT 4.0, lancé en 1996, renferme 16.5 millions de lignes. NT 5.0, qui doit sortir cette année, renfermera 27 à 30 millions de lignes. Cela représente une croissance de 700 pour-cent en seulement 6 ans.
«Les gens qui construisent des systèmes fiables ne font pas de changements radicaux très souvent,» mentionne Croll de Sun. (Solaris se maintient entre 7 et 8 millions de lignes de code.) «Les PC tendent à avoir un chargement frais et vierge de codes non testés. Le formidable nombre de lignes de code ajoute à la possibilité de bogues. Le code que vous n'écrivez pas est libre de tout bogue.»
Les ingénieurs qui travaillent avec les mainframe et les systèmes intégrés sont d'accord «Posséder 15 millions de lignes de code n'est pas aussi mauvais que posséder 15 millions de nouvelles lignes de code,» note Wayman Thomas, directeur des solutions mainframe chez Candle, qui fabriquent des logiciels d'analyse de performance pour de gros serveurs et des mainframe.
Cependant, Russ Madlener, le gestionnaire des produits de bureau chez Microsoft, déclare que l'expansion du code est maniable si les développeurs accroissent leur période de tests également. Il mentionne que le groupe travaillant sur NT a deux testeurs pour chaque programmeur. «Je ne dirais pas nécessairement que le nombre de bogues croît au même rythme que le code,» a-t-il ajouté.
C'est vrai que NT est plus résistant aux plantages que Windows 95, un plus petit OS qui est là depuis plus longtemps. Ces deux-là plantent moins souvent que le Mac OS, qui est encore plus vieux. Dans ce cas-ci, la nouvelle technologie contrebalance la jeunesse et la fougue de NT. NT a une protection de mémoire plus robuste et est basé sur un Kernel moderne, alors que Windows 95 a une protection de mémoire limitée et titube sur les restes de MS-DOS et Windows 3.1. Le Mac OS n'a presque pas de protection de mémoire et permet aux applications de coopérer dans un même espace mémoire partagé -- un héritage de ses origines remontant au début des années 80.
Tout de même, il sera intéressant d'observer si NT peut demeurer stable alors qu'il ne cesse d'engraisser. Il continuera d'engraisser parce tous veulent plus de fonctionnalités. Les vendeurs de logiciels veulent plus de fonctionnalités parce qu'ils ont besoin de vendre de nouveaux produits et des mises à jour. Les fabricants de puces et les vendeurs de systèmes ont besoin de raisons pour vendre des ordinateurs plus gros et plus rapides. Les magasines informatiques ont besoin de nouvelles choses pour leurs articles. Les utilisateurs semblent être insatiables de nouveaux gadgets, qu'ils les utilisent ou non.
«Toute l'industrie du PC ressemble à un site de bêta-testeurs,» se plaint Pavle Bojkavski, un étudiant en droit à l'université d'Amsterdam frustré par le cycle sans fin des plantages et des mises à jour pour réparer les bogues. «Pourquoi ne pas développer des ordinateurs stables en utilisant la vieille technologie ?» Ou est-ce que je ne vois pas le nombre grandissant de masochistes qui aiment être punis ?
Même s'il existe des douzaines de raisons techniques sur le plantage des PC, elles se regroupent sous deux aspects : l'accroissement de la complexité, qui à première vue est sans fin, et le peu de souci envers la fiabilité. Le marché résiste à la venue d'ordinateurs plus simples (tels que les NC) ou de petites applications (comme Microsoft Write). Pour plusieurs utilisateurs, la barre n'est pas encore assez haute.
«Si vous utilisez [Microsoft] Word et que le système plante, vous perdez un peu de travail mais pas beaucoup d'argent, et personne n'en meurt,» explique Croll de Sun. «C'est un compromis qui en vaut la peine.»
On peut regrouper les raisons techniques d'un plantage en deux catégories : les problèmes de quincaillerie et les problèmes logiciels.
Les problèmes authentiques de quincaillerie sont peu courant, mais on ne peut en ignorer la possibilité. Un des mauvais côtés associé à la baisse des prix des systèmes, c'est que les fabricants coupent dans la qualité plus que jamais. Les PC peu dispendieux ne sont pas nécessairement des PC de mauvaise qualité, mais certains le sont.
Une autre cause des plantages mystérieux, le sabotage, va au-delà du propos de cet article. Les dangers que représentent les virus, vers et les chevaux-de-troie sont bien documentés et c'est un problème de sécurité. Et, bien sûr, les comportements infâmes ne se limitent pas aux logiciels. Lors d'une étude portant sur 10,000 appels de support technique, les analystes de Workgroup Technologies ont découvert que 10 appels en un mois d'une compagnie provenaient d'utilisateurs qui s'étaient fait voler des SIMM de mémoire. Un ancien CIO a déclaré à BYTE que ses employés mettaient à jour leur système en prenant les SIMM des ordinateurs d'autres employés. (Robin des bois frappe encore).
Généralement, cependant, lorsqu'un ordinateur plante, c'est le logiciel qui fait défaut. Si c'est une application, vous risquez de perdre le travail fait dans cette application, car un bon OS devrait protéger les partitions de mémoire occupées par les autres programmes. Quelques fois, le programme ayant planté déclenche une cascade de défectuosités qui fait planter le système au complet.
Alors le seul recours est de redémarrer, sacrifiant tous travaux non sauvegardés dans les applications en cours. Et puisque ni l'OS, ni les applications n'ont la chance de quitter proprement -- en fermant les fichiers ouverts, en supprimant les fichiers temporaires, en vidant les canaux d'entrées/sorties, et ainsi de suite -- un redémarrage inopiné peut laisser des débris sur le disque dur ou même le corrompre. Cela mène à plus d'instabilité, plus de plantages et plus de pertes de données.
Alors pourquoi les programmes plantent ? Principalement pour ces deux raisons : une condition survient dans le programme que le concepteur n'a pas prévue, alors le programme n'est pas en mesure de s'occuper de cette condition; ou le programme anticipe une condition mais échoue dans sa tentative de la manipuler adéquatement.
Dans un monde parfait, chaque programme devrait être en mesure de prévoir toutes les conditions imaginables, ou tout au moins reléguer à un autre programme cette tâche, tel quel le système d'exploitation. Mais dans la vraie vie, les programmeurs ne peuvent pas tout prévoir. Quelques fois ils ignoreront délibérément des conditions qui ne se présenteront que très rarement -- peut être pour réduire la taille du code, rendre le code plus rapide ou pour respecter un échéancier. Dans ces cas, l'OS est le dernier recourt, l'arbitre des perturbations que les autres programmes ne peuvent résoudre. «Au niveau de l'OS, vous devez prévoir l'imprévisible, aussi bizarre que cela paraisse,» raconte Guru Rao, ingénieur en chef des mainframe System/390 chez IBM.
Pour faire face à ces dangers, les programmeurs doivent encapsuler toutes les opérations critiques dans du code qui redirige les erreurs vers une sous-routine spéciale. La sous-routine tente de déterminer ce qui a causé l'erreur et ce qu'elle devrait faire. Dans certains cas le programme peut récupérer en douce sans que l'utilisateur ne s'en rende compte. Dans d'autres cas le programme doit afficher un message d'erreur demandant à l'utilisateur quoi faire. Si le code de manipulation de l'erreur échoue, ou se trompe, le programme plante.
Le plantage est un terme vague utilisé pour décrire une suite infortunée d'événements. Habituellement, un programme qui plante est surpris par une exception, pris dans une boucle infinie, confus par des conditions qui s'attendent mutuellement, privé de ressources, ou corrompus par une violation de mémoire.
Les exceptions sont des erreurs en temps réel ou des interruptions qui obligent le CPU à suspendre l'exécution normale du programme. (Java est un cas spécial : la machine virtuelle Java [VM] vérifie certaines erreurs en temps réel dans le logiciel et peut appeler une exception sans que le CPU ne soit impliqué.) Par exemple, si le programme essaie d'ouvrir un fichier de données inexistant, le CPU renvoie une exception disant «Fichier introuvable.» Si le code de traitement des erreurs du programme est de mauvaise qualité ou absent, le programme devient confus.
C'est à ce moment qu'un bon système d'exploitation intervient. Il ne peut probablement pas corriger le problème, mais il peut au moins afficher le message : «Fichier introuvable : avez-vous inséré le disque approprié ?» Cependant, si le code de traitement des erreurs de l'OS est déficient, le système entier risque de planter.
Dans certains cas le programme est pris dans une boucle infinie. Parce qu'il a rencontré une condition imprévue, le programme exécute le même bloc de codes répétitivement. (Imaginez une personne vraiment stupide suivant les instructions à la lettre sur une bouteille de shampooing : «Faites mousser. Rincez. Répétez.») Pour l'utilisateur, un programme pris dans une boucle infinie apparaît gelé. En réalité, le programme s'exécute avec frénésie.
Encore ici, un bon OS interviendra afin de permettre à l'utilisateur d'arrêter sécuritairement le processus. Mais le gestionnaire de processus de certains OS a de la difficulté à traiter ce problème. Dans Windows 3.1 et le Mac OS, les gestionnaires de processus travail de manière coopérative, ce qui signifie qu'il se fie aux processus pour qu'ils coopèrent ensemble afin de ne pas s'accaparer en entier le temps de CPU. Windows 95, NT, OS/2, Unix, Linux et la majorité des autres OS modernes permettent à un processus de suspendre un autre processus.
Les conditions d'attente mutuelles sont similaires aux boucles infinies, sauf qu'elles sont provoquées habituellement par des événements extérieurs au programme. Peut être que le programme parle à un dispositif externe et que ce dernier n'est pas assez rapide pour le programme -- ou le programme ne répond pas au dispositif. D'un côté ou de l'autre, il y a un problème de communication et chacun des logiciels doit posséder du code avec temps d'expiration pour traiter cette condition.
La privation de ressources est une autre manière de planter. Habituellement, la ressource la plus rare est la mémoire. Un programme demande à l'OS de la mémoire libre; si l'OS ne peut trouver suffisamment de mémoire à cet instant, il rejette la requête.
Encore ici, le programme devrait anticiper cette condition plutôt que de faire la gueule. Si le programme ne peut fonctionner sans les ressources espérées, il peut planter sans avoir la chance d'expliquer pourquoi. Pour l'utilisateur, le programme semble gelé.
Pire encore, le programme peut assumer qu'il a obtenu la mémoire demandée. Cela mène habituellement à une violation de mémoire. Lorsqu'un programme tente d'utiliser la mémoire qu'il ne possède pas légitimement, il corrompra sa propre mémoire ou essaiera d'accéder à la mémoire extérieure à sa partition.
Ce qui arrive par la suite dépend largement des forces du système d'exploitation concernant la protection de mémoire. Un système d'exploitation vigilant ne laissera pas un programme faire un mauvais emploi de la mémoire. Lorsqu'un programme essaie d'accéder à une adresse de mémoire illégale, le CPU lève une exception. Le système d'exploitation attrape l'exception, averti l'usager avec un message d'erreur («Ce programme a essayé de faire une opération illégale : faute de page invalide»), et tente de récupérer. S'il ne peut pas, il ferme le programme ou laisse à l'usager la possibilité de sortir le programme de sa misère.
Ce ne sont pas tous les OS qui sont autant protecteur. Lorsqu'un OS n'empêche pas un accès illégal à la mémoire, le programme en faute écrase la mémoire qu'il utilise pour autre chose ou vole celle d'un autre programme. La corruption de mémoire qui en résulte déclenche une série d'exceptions qui mènent inévitablement à un plantage.
La corruption de mémoire se produit également lorsqu'un programme se trompe dans le calcul de la mémoire qu'il possède. Par exemple, un programme peut stocker de l'information dans le 101e élément inexistant d'un vecteur de 100 éléments. Lorsque le programme défonce les limites du vecteur, il écrase les données d'une autre structure. La prochaine fois que le programme lit les données de la structure corrompue, le CPU lève une exception. Vlan! Un autre plantage.
Les PC modernes souffrent d'une toute autre classe de problèmes liés à leur état -- la somme totale de toutes les informations qui définissent le statut de l'ordinateur ou condition. L'information de l'état comprend tous les logiciels installés sur le disque dur, les fichiers de configuration, les réglages du panneau de contrôle, les données paramétrisable du BIOS, et les réglages des préférences de l'utilisateur. C'est tout ce qui rend un système différent d'un autre système pour une quincaillerie identique.
Avant que les PC aient des disques durs, ils étaient essentiellement sans état. Ils emmagasinaient tout sur des disquettes et des rubans magnétiques. Les utilisateurs et administrateurs n'avaient jamais à installer, désinstaller ou gérer des logiciels sur un système. Parce que l'information de l'état était indépendante de la machine, ils étaient quasiment imperméables aux désastres. Si un météore avait détruit votre PC, vous auriez pu le remplacer avec un autre PC et vous mettre au travail immédiatement. Il n'y avait rien à réinstaller ou à rebâtir. (Aujourd'hui, les NC tentent de recréer l'ordinateur sans état en emmagasinant tout sur un serveur).
Les PC modernes, quant à eux, renferme une immense réserve d'informations d'état qui change constamment. Même lorsque vous fixez l'écran, un bref éclair d'activité sur le disque dur peut signifier que votre ordinateur modifie ses réglages de registre en arrière-plan. Les problèmes débutent lorsqu'un changement d'état débalance votre système. Cela survient habituellement suite à l'installation de nouveaux logiciels -- une nouvelle version du système d'exploitation, une nouvelle application, une mise à jour d'un pilote de périphérique (driver), ou tout autre chose. Soudainement le système ne réagit plus comme d'habitude. Vous êtes la victime d'un conflit de logiciels souvent incroyablement difficile à réparer parce que vous n'êtes pas certain de ce qui a été modifié.
Deux des plus grands coupables sont les DLL sur les PC avec Windows et les extensions sur les Macs. Les DLL sont des librairies de code que des programmes peuvent partager. Les extensions sont des programmes qui s'accrochent au système d'exploitation du Mac lors du démarrage pour modifier le comportement du système ou augmenter les possibilités d'une application. Les deux types de composantes augmentent les risques de problèmes.
Un des problèmes courant survient lorsqu'un logiciel d'installation remplace bêtement une version récente d'une composante avec une version plus ancienne. L'application nouvellement installée fonctionne bien, mais une application déjà existante pourrait commencer à planter. Les utilisateurs ne savent pas vraiment qui blâmer. Résultat : une série d'appels frustrants au support technique.
Est-ce que le logiciel d'installation ne devrait pas vérifier chaque fois la date d'une composante avant de la remplacer ? Hélas, ce n'est pas aussi simple. Quelques fois la date n'est pas bonne ou peut être a-t-elle été modifiée. Windows permet à un logiciel d'installation d'interroger un DLL pour connaître sa version, ce qui est plus sécuritaire. Mais même si tous les logiciels d'installation prenaient cette précaution, la gestion des versions n'est qu'un des problèmes. «Certaines compagnies tendent à modifier des fonctions dans un DLL courant sans prévenir et ces modifications peuvent causer des problèmes avec les applications existantes,» raconte Dave Galligher, directeur du développement des produits chez Cougar Mountain Software, un vendeur de logiciels de comptabilité.
Les programmes s'attendent à ce que leurs DLL renferment des fonctions portant un nom particulier, une liste de paramètres et des valeurs de retour. Cependant Windows n'a aucun mécanisme permettant d'interroger les DLL pour confirmer ces informations. Un programme qui compte sur une fonction d'un DLL pour lui retourner un entier de 32 bits pourrait aisément planter si une version différente du DLL retourne un entier de 64 bits à la place.
Le problème lié à la gestion de l'état d'un système a engendré une sous-industrie remplie de programmes utilitaires et d'outils de gestion : CleanSweep, Conflict Catcher, Extension Manager, First Aid Deluxe, Norton Utilities, Oil Change, RealHelp, TuneUp, Uninstaller, et des douzaines d'autres. Les vendeurs de systèmes d'exploitation ajoutent rapidement des caractéristiques de gestion à leur système également. Tout simplement parce que les PC d'aujourd'hui demandent plus de soins qu'un tonneau rempli de Tamagotchi.
C'est également un exemple typique d'une complexité précipité. Les composantes telles que les DLL furent inventées pour diminuer la complexité; les programmes ne grossiraient pas rapidement s'ils partageaient un code commun. Mais les logiciels d'installations ont répandu tant de DLL partout sur le disque dur, qu'ils ont créé un nouveau problème. C'est cela, en retour, qui a encouragé l'industrie à produire de nouveaux outils de gestion, utilitaires et caractéristiques d'OS -- encore plus de complexité. Cela démontre brillamment la difficulté qu'on aura à transformer les PC en des systèmes réellement fiables.
«Les coûts de gestion les plus élevés dans un environnement informatique proviennent de la gestion des PC,» déclare Steve Mann, vice-président de la stratégie des produits chez Computer Associates. «Ils ne sont pas vraiment administrables et ils ne sont pas très standardisés en termes de configuration.»
Le travail de gestion des PC est directement relié à la fiabilité. Dans un sondage effectué auprès de 1800 professionnels de l'informatique à la conférence internationale Computer Associates de 1997, 70 pour-cent des répondants étaient d'accord pour dire que les mainframe étaient plus fiables que les systèmes client/serveur basés sur des PC. «Ce n'est que récemment que les administrateurs ont commencé à exiger le même niveau d'administration et de fiabilité auxquels ils sont habitués avec les mainframe et les gros serveurs,» ajoute Mann.
Toute solution doit débuter par la façon utilisée par les développeurs pour écrire, tester et déboguer leur code source. Au-delà de cela, les logiciels d'installation doivent faire un meilleur travail de chargement des programmes sur les systèmes. Finalement, les systèmes d'exploitation et les applications doivent travailler ensemble pour rendre les PC plus faciles à gérer.
Au risque d'enflammer une nouvelle guerre, il est logique de porter une large portion du blâme sur le C et le C++. «Écrire en C ou C++ équivaut à utiliser une scie mécanique sans aucune sécurité,» déclare Bob Gray, directeur senior pour les services de consultation chez Virtual Solutions, un développeur de solutions industrielles sur mesure. «C'est puissant, mais c'est facile de vous couper les doigts.»
Très peu, s'il en existe, de langages de programmation vous permettent d'écrire aussi facilement du mauvais code. Bien sûr, tous peuvent écrire du mauvais code en utilisant n'importe quel langage, mais le C et le C++ sont impardonnables. L'industrie informatique a statué sur le C/C++ pour le développement de logiciels commerciaux une décennie auparavant, créant une montagne de logiciels remplis de bogues qui nous enterons pendant les décennies à venir.
Les intransigeants protestent que c'est la liberté offerte par le C/C++ qui le rend si rapide. Mais la quincaillerie du PC devient si rapide de toute manière que c'est le temps de mettre de l'avant la fiabilité. Des années plus tard, alors que les vieux mais indispensables programmes C/C++ continueront à planter, l'excuse selon laquelle le C/C++ préserve chaque cycle de CPU aura perdu tout son sens -- de même que celle voulant que la codification de l'année sur deux chiffres permettait de préserver deux octets de stockage.
Quelle est l'alternative ? Tous les outils de quatrième génération (4GL) sont plus sécuritaires, incluant Delphi, PowerBuilder, TopSpeed, Smalltalk et Visual Basic. Peut être que le meilleur exemple d'un langage moderne est Java. Il renferme de nombreuses protections qui arrêtent plusieurs bogues avant qu'ils ne surviennent.
La précipitation des cycles de développement est une autre source de problèmes. «Si vous regardez l'industrie aujourd'hui, on observe des cycles de développement de 6 ou 9 mois plutôt que 18,» déclare Gary Ulaner, directeur des produits chez Quarterdeck's RealHelp. «Il y a également plus de programmeurs faisant du développement de logiciels et ils n'ont pas tous le même niveau de discipline concernant l'assurance de la qualité. Les exigences du marché et des revenus sont souvent la cause de produits livrés avant qu'ils ne soient prêts.»
Une solution douteuse est le bêta-test public. Il fut un temps où vous deviez être quelqu'un de spécial pour devenir un bêta-testeur. Maintenant tous ceux qui ont un ordinateur, un modem et qui ne se soucient pas de la stabilité de leur système, peuvent tester des logiciels bêta. Le fait de pouvoir utiliser des produits avant leur mise en marché (même si des millions d'autres gens font la même chose) a rendu les tests publics bêta à la mode. Cependant ces tests sont également responsables de la propagation de code rempli de bogues, laissant dans leur sillage des plantages de système et des disques durs ruinés.
«Certaines personnes ne réalisent pas ce que bêta signifie,» mentionne Gray de Virtual Solutions. «Ce beaucoup plus qu'un simple truc permettant d'obtenir une copie d'un logiciel avant sa sortie.»
C'est la vérité, les bêta-tests publics exposent du code frais à la masse. Mais combien de bêta-testeurs rapportent les bogues découverts ? -- y en a-t-il ? Combien d'entre-eux se soucient de retirer de leur système le logiciel bourré de bogues (incluant toutes ses composantes cachées) une fois le produit final livré ? Combien d'entre-eux réalisent les torts qu'ils occasionnent à leur système ?
Madlener de Microsoft défend la pratique des bêta-tests mais reconnaît que les développeurs et les utilisateurs devraient être plus prudents. «Récemment nous avons relu le message de renonciation livré avec les produits bêta,» ajoute-t-il. «Il responsabilise le bêta-testeur de sorte qu'il n'installe pas la version bêta sur un système critique.»
La prochaine étape est l'installation du logiciel -- les logiciels d'installation doivent devenir plus intelligents. OS/Warp 4 possède un logiciel d'installation intégré qui s'assure que les bons fichiers sont enregistrés aux bons endroits sans écraser d'autres composantes. Il n'est pas utilisé uniquement pour installer le logiciel du système d'exploitation; les développeurs peuvent l'utiliser pour leurs applications. Les logiciels d'installation sous Unix, qui existent depuis longtemps déjà, font la même chose. Il existe également de bons logiciels d'installation provenant de compagnies indépendantes, tels que InstallShield pour Windows et Installer VISE de MindVision pour le Mac.
Madlener mentionne que Windows NT 5.0 aura un nouveau service d'installation d'applications, qui ressemble à ce que possède OS/2. Cela signifie que les développeurs n'auront plus à écrire leur propre code d'installation. NT 5.0 exécutera un script qui indiquera où chaque fichier doit aller. NT détectera tout conflit entre DLL et conservera un journal de tous les nouveaux fichiers installés et les modifications au registre. Selon Madlener, cela facilitera la désinstallation des logiciels ou la réinstallation de composantes individuellement.
Madlener ajoute qu'il ne sait pas si les autres versions de Windows auront ce nouveau service d'installation, mais mentionne que Windows 98 aura un nouvel outil de gestion appelé «File System Checker». C'est un programme de diagnostic qui vérifie les composantes du système et qui peut réinstaller toutes pièces manquantes ou défectueuses. Il conserve également un journal qui représente un cliché de l'état du système, ce qui permet de revenir en arrière plus facilement.
Une solution intéressante à la maintenance d'un système, mais potentiellement dangereuse, est la mise à jour automatique. Peu d'utilisateurs et d'administrateurs ont le temps de parcourir Internet pour trouver les dernières mises à jour ou patch. C'est ce qui a ouvert la porte à des utilitaires tels que Oil Change de CyberMedia ainsi que TuneUp et RealHelp de Quarterdeck. Ils comparent la configuration de votre système avec une base de données située sur le Web, puis ils vous accompagnent dans le téléchargement et l'installation des mises à jour qui sont appropriées. C'est une bonne idée, suffisante pour faire réfléchir Microsoft qui pense ajouter une fonctionnalité semblable à Windows.
Mais il y a un danger: chaque modification de l'état de votre système, même mineure, peut potentiellement nuire à un logiciel existant. Un vieux programme peut planter avec un nouveau DLL ou un nouveau pilote de dispositif, vous obligeant à mettre ce programme à jour également. Quelques fois cela déclenche une série de mises à jour et de réparations avant que le système ne retrouve un état stable. Dans d'autres cas vous frappez un cul-de-sac car aucune mise à jour d'un programme défectueux n'est disponible. Et inévitablement, les mises à jour consomment plus de mémoire, d'espace disque et de CPU, précipitant le jour où votre PC deviendra désuet.
Le phénomène des nouveaux logiciels qui rendent les anciens défectueux est bien connu des ingénieurs de logiciels. Alan Wood, ingénieur senior chez Tandem Computer, raconte que les réparations dans le NonStop Kernel de Tandem brise quelque chose d'autre dans le système d'exploitation dans 5 à 10 pour-cent du temps. Tandem isole ces problèmes en réalisant de minutieux tests. Cependant c'est difficile d'entreprendre ce genre de tests sur les PC : chaque PC est légèrement différent.
Des utilitaires tels que Oil Change et TuneUp reconnaissent ce danger. Ils journalisent chacune des modifications et sauvegardent les composantes remplacées dans une archive compressée, ainsi vous pouvez annuler l'installation. Mais il y a encore des chances pour que vous soyez pris dans un tourbillon de modifications sans être capable de revenir en arrière.
Les applications ont également leur part de responsabilité dans la gestion d'un système. Lorsqu'un utilisateur lance Office 98 pour le Mac, il exécute un auto-diagnostic. S'il ne peut localiser une seule de ses librairies partagées -- peut-être l'utilisateur a-t-il désactivé par erreur une librairie en utilisant le gestionnaire d'extensions -- Office 98 en installe une copie fraîche à partir d'une archive compressée située sur le disque dur. Tout cela se fait sans que l'utilisateur en soit prévenu. Microsoft mentionne que les prochaines versions d'Office pour Windows auront cette capacité d'auto-réparation.
Bien sûr, chaque nouvelle fonctionnalité, outil de gestion, mise à jour du système d'exploitation et programme utilitaire ajoute encore plus de code et de complexité au système. Certains experts affirment que les PC continueront à planter tant que les utilisateurs consommeront des fonctionnalités futiles. En d'autres mots, le chemin le plus court vers la stabilité est la simplicité : quincaillerie simple, logiciel simple, interfaces-utilisateurs simples. Mais cela requière une toute nouvelle façon de penser, déclare Michael L. Dertouzos, directeur du MIT Laboratory for Computer Science : «C'est plus compliqué, un peu comme le contrôle des naissances.»
Il mentionne que le changement, s'il survient un jour, débutera par un mouvement de rébellion. Quelqu'un utilisera le Web pour distribuer un système d'exploitation simplifié qui rivalisera avec les plates-formes bien établies. Il sera plus stable, plus facile à utiliser et à comprendre.
Ça ressemble beaucoup à ce qui se produit aujourd'hui avec Linux, ou les premiers jours de Mosaic. Mais Linux échoue le test de la simplicité et Mosaic a été supplanté par Navigator qui a été supplanté par Communicator. Les logiciels simples ne durent pas longtemps.
À l'autre extrême se trouve le concept du NC : un client simplifié, sans état, conçu pour un monde branché. Mais le NC sacrifie l'essence cruciale d'un PC -- le contrôle local sans limites. Les mainframe et les systèmes intégrés ont un taux élevé de stabilité en sacrifiant le contrôle local. Pour le meilleur ou pour le pire, plusieurs utilisateurs et informaticiens préfèrent planter plutôt que de changer.
Voilà pourquoi la solution ultime est encore loin. Soyons réaliste, les développeurs continueront à écrire de plus gros programmes livrés avant qu'ils ne soient prêts. Les systèmes d'exploitation augmenteront en complexité. Les utilisateurs continueront à placer leurs dollars dans les logiciels bourrés de fonctionnalités. Les applications et plates-formes bien établies continueront à porter ombrage aux alternatives plus radicales. Et les PC continueront à planter.