Circuits intégrés, transistors, multitâches, transmission par commutation de paquets, gestion de base de données, l'informatique fait des pas de géant dans les années 1960. Et ce ne sont pas les seuls !

Deux révolutions d'apparence plus modeste vont se révéler très déterminantes par la suite. Il s'agit de deux concepts opposés : Le premier s'appelle BASIC et va concerner plutôt les néophytes, le second s'appelle OOP (Object-oriented programming) en français POO (Programmation Orienté Objet) et concernera plutôt les professionnels de l'industrie du développement logiciel qui commence sérieusement à se mettre en place.

C'est en 1964 au Dartmouth College à Hanover, État du New Hampshire, que deux Américains, John George Kemeny d'origine hongroise et Eugène Kurtz, ont développé le Beginner's All-purpose Symbolic Instruction Code (Code d'instructions symboliques multiusages du débutant) autrement dit, le langage BASIC.

L'idée était de permettre aux étudiants non scientifiques de se familiariser avec les langages de programmation.

Inspiré du FORTRAN, le BASIC était beaucoup plus simple et interactif. En effet, le fait qu'il soit interprété et non pas forcément compilé permettait d'exécuter les programmes jusqu'à ce que se produise une erreur. Cette dernière, si elle avait lieu, était donc plus facile à repérer et à corriger qu'avec les langages compilés de l'époque.

Quant aux étudiants scientifiques, le BASIC était l'occasion de les faire plancher sur la réalisation d'un interpréteur. Ce genre d'exercice, devenu un grand classique, a tout simplement permis à un certain Bill Gates de démarrer sa carrière en 1975, avec son ami Paul Allen, par la commercialisation d'un interpréteur BASIC pour l'ALTAIR 8800 et devenir l'homme le plus riche du monde vingt ans après.

Un petit exemple :

Vous pourrez retrouver cet exemple avec des commentaires dans le lien concernant Le langage BASIC dans la page "En savoir plus".

Hé oui ! On y retrouve notre fameux GOTO et la programmation spaghetti tant décriée. Il n'empêche que le BASIC permettra, dans les décennies qui suivront, d'éveiller des vocations d'informaticien chez beaucoup de personnes de tous âges à partir du moment où elles avaient accès à un ordinateur personnel.

La liste est longue des machines fournies avec un BASIC : Olivetti P6060, Amstrad, Thomson MO5 et TO8, Apple I, II et III, Commodore, Sinclair ZX, certaines calculatrices et bien entendu l'IBM PC avec son Basica et la version pour les compatibles PC GW-BASIC...

Par ailleurs, le BASIC va évoluer. Il deviendra mieux structuré et pourra être compilé. Microsoft proposera QuickBasic puis Visual BASIC avec un environnement de développement intégré et Borland fera de même avec son Turbo Basic qui deviendra par la suite PowerBasic.

De nombreuses autres versions dont des versions libres de droits seront développées.

Au cours des années 1980, des langages mieux structurés et plus efficaces comme le Turbo Pascal de Borland ont été préférés au BASIC qui s'est mis à décliner.

Actuellement BASIC est très peu employé, mais Visual Basic se retrouvait quand même à la 19e place de l'Index TIOBE des langages de programmation les plus plébiscités en juin 2019.

Voilà pour les néophytes qui ont donc pu, depuis les années 60, s'initier à la programmation relativement facilement, à condition toutefois d'avoir accès à une machine.

Pour les professionnels, ce sera une autre histoire. Des informaticiens comme Ole-Johan Dahl et Kristen Nygaard et plus tard Alan Kay vont créer de nouveaux paradigmes de programmation en recherchant l'efficacité, la fiabilité ainsi que la possibilité de travailler en équipe plus rapidement sur des projets de plus en plus gros.

C'est ainsi que va naître Flex, le premier langage, basé en partie sur le paradigme orienté objet, inspiré des travaux de Ole-Johan Dahl et Kristen Nygaard sur le langage Simula et qui donnera en 1972 la première version de Smalltalk, considéré comme le premier véritable langage de POO.

Dans les années 80, Bjorn Stroustrup intègre la programmation orientée objet dans le langage C et crée le langage C++ qui aura dès lors un très grand succès. Par la suite, ce paradigme sera adopté par de nombreux langages : Eiffel, Python, Ruby, Java, PHP (à partir de la version 3), JavaScript et bien d'autres.

Expliquer vraiment en quelques lignes en quoi consiste la POO est illusoire. Sachez tout d'abord qu'il est plus simple de débuter par l'apprentissage d'un langage orienté objet que de commencer par faire de la programmation procédurale pendant des années et de passer ensuite à la POO. Il est alors très difficile de se débarrasser de ses habitudes et d'être à l'aise avec des concepts radicalement différents. Apprendre les deux en même temps est sans doute l'idéal.

Jusqu'ici, nos exemples étaient écrits en programmation procédurale. On y trouvait essentiellement des données sous forme de constantes ou de variables et du code faisant appel à des fonctions, le tout ayant pour but d'utiliser ou de modifier ces données. Les données étaient en quelque sorte indépendantes du code.

En POO, on considère les données comme étroitement liées au code et cela va donner une tout autre façon d'appréhender la programmation. On va créer des objets qui auront des caractéristiques (des variables associées, une couleur par exemple) et des comportements (des fonctions, par exemple s'afficher à l'écran). Et pour distinguer la POO de la programmation procédurale, on va faire appel à un tout autre vocabulaire.

Les données, constantes et variables, deviendront les propriétés ou attributs des objets. Les fonctions deviendront des méthodes. Les objets eux-mêmes ne seront pas définis directement, mais seront des instanciations ou plus simplement des instances d'une classe, la classe n'étant pas en général un véritable objet, mais plutôt un modèle servant à créer des objets.

Voici un petit schéma pour éclairer tout ça :

class Maclasse
{
  private Attribut1;
  private Attribut2;

  public function fonction1()
  {
    ligne_de_code1;
    ligne_de_code2;
    ligne_de_code3;
  }
}
MonObjet = new Maclasse;
ligne_de_code;
...

    class Maclasse
    {
        private Attribut1;
        private Attribut2;

        public function fonction1()
        {
            ligne_de_code1;
            ligne_de_code2;
            ligne_de_code3;
        }
    }
    MonObjet = new Maclasse;
    ligne_de_code;
    ...

Vous pouvez imaginer ici par exemple que Maclasse va gérer une alerte à l'écran, les attributs seront le texte et la couleur et la fonction servira à afficher l'objet créé (MonObjet) à un endroit précis et pendant un temps donné.

Notez au passage que l'on pourra créer des classes qui héritent des attributs et des méthodes d'une classe existante (par exemple une classe Chat et une classe Chien qui hériteront chacun d'une classe Animal).

On peut ainsi créer tous les objets dont l'application aura besoin, ce qui suppose, avant d'écrire la moindre ligne de code pour les concevoir et les faire interagir, de réfléchir très précisément aux fonctionnalités nécessaires au projet.

Par la suite, les différentes classes seront considérées comme des boîtes noires dans lesquelles le programmeur n'aura plus à intervenir, c'est le principe de l'encapsulation.

Vous vous en doutez, ces concepts vont permettre de travailler beaucoup plus facilement sur de très gros projets et surtout de travailler à plusieurs sur différentes parties d'un même projet sans que le code des uns soit modifié accidentellement par d'autres.