Chapitre 3

Le logiciel initial (1950-1960)

Si le matériel constituait la structure physique des premiers ordinateurs, les logiciels représentaient l'intelligence qui les animait, permettant de transformer les circuits électroniques en outils de calcul et de traitement de l'information. Dans les premières années de l’informatique, le développement de logiciels était une activité pionnière, souvent étroitement liée à une connaissance détaillée de l’architecture matérielle. Dans ce chapitre, nous explorerons les premières formes de logiciels, des langages machine et assembleur aux premiers langages de programmation de haut niveau et aux concepts rudimentaires de système d'exploitation.

3.1 Langage machine :
Parler directement au matériel

La forme de logiciel la plus élémentaire est le langage machine . Il s'agit du langage natif compris directement par l'unité centrale de traitement (CPU) d'un ordinateur. Chaque type de CPU possède son propre langage machine spécifique, constitué d'une séquence d'instructions binaires (séquences de 0 et de 1). Chaque instruction du langage machine correspond à une opération élémentaire que le CPU peut effectuer, telle que :

Opérations arithmétiques : Additionner, soustraire, multiplier, diviser des nombres.
Opérations logiques : Effectuer des opérations logiques booléennes (AND, OR, NOT) sur les bits.
Transfert de données : Déplacer les données entre la mémoire et les registres du processeur.
Contrôle de flux : Changer l'ordre dans lequel les instructions sont exécutées (sauts conditionnels et inconditionnels).

Programmer directement en langage machine était une tâche extrêmement ardue et complexe pour plusieurs raisons :

Difficultés de lecture et d'écriture : Les séquences binaires sont difficiles à interpréter et à mémoriser pour les humains. Un programme simple peut nécessiter des séquences longues et complexes de 0 et de 1.
Dépendance à l'architecture matérielle : Le langage machine est spécifique à une architecture CPU particulière. Un programme écrit pour un type d’ordinateur ne pourrait pas fonctionner sur un autre avec une architecture différente.
Risque élevé d'erreurs : La manipulation directe de séquences binaires a rendu extrêmement facile les fautes de frappe ou les erreurs de logique.
Difficulté de débogage : Trouver et corriger des erreurs dans un programme écrit en langage machine était un processus long et frustrant.

Malgré ces difficultés, les premiers programmeurs devaient nécessairement travailler à ce niveau pour faire fonctionner les premiers ordinateurs. La programmation en langage machine nécessitait une compréhension approfondie de l’architecture matérielle informatique et une grande attention aux détails.

3.2 Langage d'assemblage :
Un pas vers l'abstraction

Pour simplifier la tâche de programmation, le langage assembleur a été développé.

Ce langage est une représentation symbolique du langage machine. Au lieu d'utiliser des séquences binaires, le langage assembleur utilise des mnémoniques (abréviations courtes) pour représenter les instructions du langage machine et des noms symboliques pour représenter les adresses mémoire.

Par exemple, une instruction en langage machine pour ajouter deux nombres pourrait être représentée en langage assembleur avec un mnémonique tel que ADD suivi des noms des registres ou des adresses mémoire contenant les nombres à ajouter.

Afin d'exécuter un programme écrit en langage assembleur sur un ordinateur, un programme spécial appelé assembleur était nécessaire. L'assembleur traduit chaque instruction du langage assembleur en instruction du langage machine correspondante.

L'utilisation du langage assembleur offrait plusieurs avantages par rapport à la programmation directe en langage machine :

Plus grande lisibilité et écriture : Les mnémoniques étaient plus faciles à retenir et à interpréter que les séquences binaires.
Utilisation de noms symboliques : Autorisé les programmeurs à faire référence à des adresses mémoire et à d'autres entités en utilisant des noms symboliques au lieu d'adresses numériques, simplifiant la gestion de la mémoire et réduisant le risque d'erreurs.
Productivité accrue : La programmation d'assemblage était plus rapide et moins sujette aux erreurs que la programmation en langage machine.

Cependant, le langage assembleur restait encore un langage de bas niveau, étroitement lié à l'architecture matérielle de l'ordinateur.

Les programmeurs devaient encore avoir une bonne compréhension du fonctionnement interne du processeur et de la mémoire. De plus, un programme écrit en assembleur pour une architecture particulière ne pouvait pas être facilement porté sur une autre.

3.3 Les premiers langages de programmation de haut niveau :
Vers l'indépendance matérielle

La complexité croissante des problèmes que les ordinateurs voulaient résoudre et la difficulté de programmer dans des langages de bas niveau ont conduit au développement de langages de programmation de haut niveau . Ces langages ont été conçus pour être plus proches du langage humain et plus indépendants de l'architecture matérielle spécifique de l'ordinateur. Une seule commande dans un langage de haut niveau peut correspondre à plusieurs instructions en langage machine.

Afin d'exécuter un programme écrit dans un langage de haut niveau, un programme spécial appelé compilateur ou interpréteur était nécessaire. Un compilateur traduit l'intégralité du programme de langage de haut niveau en langage machine (ou en langage intermédiaire) avant son exécution. Un interprète, quant à lui, traduit et exécute le programme ligne par ligne.

Dans les années 1950, certains des premiers et des plus influents langages de programmation de haut niveau ont émergé :

FORTRAN (FORMula TRANslation) : Développé par une équipe dirigée par John Backus chez IBM à partir de 1954, FORTRAN a été conçu spécifiquement pour les applications scientifiques et techniques nécessitant des calculs numériques intensifs. FORTRAN offrait une syntaxe plus similaire à la notation mathématique et fournissait des constructions spécifiques pour manipuler des tableaux et des matrices.
Son succès a été immédiat dans la communauté scientifique et technique, et FORTRAN continue d'être utilisé aujourd'hui dans certains domaines de recherche et développement. Son introduction a représenté une étape fondamentale vers la simplification de la programmation scientifique.
COBOL (COMmon Business-Oriented Language) : Développé à partir de 1959 par un comité dirigé par Grace Hopper, COBOL a été conçu pour les applications commerciales et de traitement de données. L'objectif était de créer un langage facile à comprendre et à utiliser par des experts non informatiques, tels que des managers et des analystes commerciaux. COBOL a mis l'accent sur la lisibilité et a fourni des constructions spécifiques pour gérer de grandes quantités de données, créer des rapports et interagir avec des fichiers. COBOL est rapidement devenu le langage dominant pour les applications professionnelles et a conservé une importance considérable pendant des décennies. De nombreux systèmes critiques d'entreprise existants sont encore écrits en COBOL aujourd'hui.
LISP (LISt Processing) : Développé par John McCarthy au MIT en 1958, LISP a été conçu pour la recherche sur l'intelligence artificielle et pour la manipulation de symboles et de listes. Sa syntaxe, basée sur l'usage intensif des parenthèses, était radicalement différente de celle du FORTRAN et du COBOL. LISP a introduit des concepts innovants tels que la récursivité et le traitement des fonctions comme des données. Bien qu'il n'ait pas atteint la popularité du FORTRAN et du COBOL dans d'autres domaines, LISP a eu une influence significative sur la recherche en intelligence artificielle et le développement d'autres langages de programmation.

Le développement de ces premiers langages de haut niveau a représenté une énorme simplification pour les programmeurs, leur permettant de se concentrer sur la logique du problème à résoudre plutôt que sur les détails de l'architecture matérielle.

Cela a conduit à une plus grande productivité et à la capacité de résoudre des problèmes plus complexes avec les ordinateurs.

3.4 Concepts des premiers systèmes d'exploitation (traitement par lots)

Dans les premières années de l’informatique, il n’existait pas de systèmes d’exploitation complexes comme ceux auxquels nous sommes habitués aujourd’hui. L'interaction avec l'ordinateur était souvent directe et le programmeur devait gérer manuellement toutes les ressources de la machine. Cependant, à mesure que la puissance et la complexité des ordinateurs augmentaient, le besoin de logiciels capables de gérer les ressources matérielles et de simplifier l’exécution des programmes s’est fait sentir.

L'une des premières formes de gestion des tâches sur ordinateur était le traitement par lots . Dans cette approche, un ensemble de tâches (c'est-à-dire des programmes à exécuter avec leurs données d'entrée) ont été collectés dans un « lot ». L'opérateur informatique chargeait le lot de travaux dans l'ordinateur, qui les exécutait les uns après les autres en séquence, sans intervention directe du programmeur lors de l'exécution. Les résultats de chaque travail étaient ensuite produits sous forme de sortie (par exemple, sur bande magnétique ou sur imprimante).

Le traitement par lots présentait certains avantages :

Plus grande efficacité : Cela a permis d'utiliser l'ordinateur de manière plus continue, réduisant ainsi les temps d'arrêt entre l'exécution d'un travail et un autre.
Simplification de la gestion : L'opérateur n'avait qu'à charger le lot initial puis à collecter les résultats, sans avoir à interagir en permanence avec l'ordinateur.

Cependant, le traitement par lots avait également des limites :

Manque d'interactivité : Le programmeur n'a pas pu interagir avec le programme pendant l'exécution. Si une erreur se produisait, vous deviez attendre la fin du travail pour analyser la sortie.
Temps d'attente longs : Si une tâche était longue, les autres tâches du lot devaient attendre qu'elle se termine.

Malgré ces limitations, le traitement par lots a représenté un premier pas vers le développement de systèmes d'exploitation modernes, introduisant le concept de gestion automatique de l'exécution des programmes.

3.5 Défis et innovations dans les premiers développements logiciels

Le développement de logiciels dans les premières années de l’informatique était une activité extrêmement difficile. Les programmeurs ont été confrontés à de nombreux défis :

Matériel coûteux et limité : Les ressources matérielles des premiers ordinateurs étaient rares et coûteuses. Les programmeurs ont dû soigneusement optimiser leur code pour tirer le meilleur parti de la mémoire disponible et de la puissance de calcul.
Outils de développement rudimentaires : Il n'existait pas d'environnements de développement intégrés, de débogueurs sophistiqués et de bibliothèques de logiciels auxquels nous sommes habitués aujourd'hui. La programmation était souvent un processus manuel et méticuleux.
Manque de standardisation : Il n'existait pas de normes largement acceptées pour les langages de programmation et les interfaces matérielles, ce qui rendait la portabilité des logiciels difficile.
Communauté de développeurs limitée : La communauté de programmation était petite et les connaissances et techniques de programmation évoluaient constamment.

Malgré ces difficultés, les pionniers du logiciel ont fait preuve d'une grande créativité et d'ingéniosité en développant les premiers programmes et en jetant les bases de la discipline du génie logiciel. L’introduction des langages de haut niveau, bien qu’initialement accueillie avec scepticisme par certains préférant le contrôle offert par les langages de bas niveau, s’est avérée être une étape cruciale pour rendre la programmation plus accessible et plus productive.

Les premiers logiciels des années 1950 se caractérisent par le passage de la programmation directement en langage machine à l'utilisation de langages assembleurs et, surtout, des premiers langages de programmation de haut niveau tels que FORTRAN, COBOL et LISP. Ces langages représentaient une abstraction importante du matériel, simplifiant la tâche de programmation et ouvrant la voie à de nouvelles applications pour ordinateurs. En parallèle, les premiers concepts de systèmes d'exploitation ont émergé, comme le traitement par lots, qui visait à améliorer l'efficacité de l'utilisation de précieuses ressources matérielles. Les défis liés au développement de logiciels étaient considérables, mais l'ingéniosité et la détermination des premiers programmeurs ont jeté les bases de l'explosion ultérieure du monde du logiciel.