Code machine

La séquence de chiffres binaires qui peut être comprise et exécutée directement par un ordinateur est appelée code machine (machine code) (Figure 4.5). Le code machine est le langage le plus bas niveau. Il est également connu sous le nom de code binaire (binary code). C'est un programme au format natif qui peut être compris par un CPU, sous la forme d'une longue série de 0 et de 1. Le code machine, ou code binaire, est le seul modèle de calcul qu'un ordinateur peut exécuter ; un programme écrit dans tout autre langage doit être compilé ou interprété en code machine avant que le programme ne puisse s'exécuter. Le CPU d'un ordinateur est une puce informatique capable d'exécuter des programmes en code machine (Figure 4.6). Il est peu pratique pour les humains de travailler directement avec le code machine car un programme en code machine n'est pas conçu pour être lisible par l'homme. Les motifs de 0 et de 1 sont conçus pour être pratiques à décoder par un CPU, et non pour être manipulés par des humains ; et de tels programmes sont longs, typiquement des millions ou des milliards de bits. Un autre obstacle est que le code machine est dépendant du matériel. Comme discuté dans 5.3 Représentation de l'information au niveau machine, chaque architecture de processeur a son propre langage machine, de sorte que le langage machine écrit pour une architecture ne peut pas fonctionner sur une autre architecture. Lorsque les tout premiers ordinateurs numériques ont été construits, et que les langages de programmation n'avaient pas encore été inventés, les programmeurs n'avaient d'autre choix que d'écrire le code machine à la main. Cependant, cela est extrêmement chronophage et sujet aux erreurs, de sorte que ce n'est presque jamais fait aujourd'hui.

Figure 4.5 Le code machine, avec ses 0 et ses 1, est le seul modèle de calcul qu'un ordinateur peut exécuter. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Figure 4.6 Une puce informatique est l'unité centrale de traitement d'un ordinateur. (source : modification de « IIci » par raneko/Flickr, CC BY 2.0)

Langage d'assemblage

Le langage de bas niveau dans lequel chaque instruction correspond directement à une instruction machine est appelé langage d'assemblage (assembly language). Le langage d'assemblage est un petit pas au-dessus du code machine mais reste un langage de très bas niveau. Le langage d'assemblage est une représentation textuelle du code machine. Tout comme un programme en code machine, un programme en langage d'assemblage est une série d'instructions qu'un CPU exécutera. Cependant, plutôt que d'écrire les instructions dans un format binaire de 0 et de 1, chaque instruction a un nom textuel tel que « ADD » ou « MOVE ». Un assembleur (assembler) est un programme qui traduit le code source du langage d'assemblage en code machine. Comme le montre la Figure 4.7, un assembleur traduit chaque instruction textuelle en la liste correspondante de bits 0 et 1.

Figure 4.7 Un assembleur est un programme qui traduit le code source du langage d'assemblage en code objet machine. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Bien qu'il soit pratiquement impossible pour un humain d'écrire un programme complet en code machine, l'écriture de programmes en langage d'assemblage est viable. Parce que le langage d'assemblage est extrêmement bas niveau, ces programmes ont tendance à s'exécuter rapidement, mais ils sont exigeants en main-d'œuvre à écrire et sont dépendants de la machine. Ce type de programmation était suffisant dans les années 1960, 1970 et 1980, lorsque les logiciels étaient écrits pour des machines uniques à forte intensité de capital, telles que des mainframes de plusieurs millions de dollars ou des véhicules spatiaux. Le travail des programmeurs était alors relativement bon marché, et il n'était pas nécessaire de déplacer les programmes vers différents matériels. Mais aujourd'hui, nous nous attendons à ce que les applications soient compatibles avec plusieurs types de plateformes, y compris les téléphones, les ordinateurs et les systèmes de jeu. Le travail des programmeurs est plus coûteux que le matériel informatique, de sorte qu'écrire des programmes entiers en langage d'assemblage n'est pas rentable. Par conséquent, les programmes sont souvent écrits principalement dans un langage de haut niveau, le langage d'assemblage étant utilisé pour écrire de courts extraits au besoin. Écrire du code dans un langage de niveau supérieur facilite l'écriture de code correct et sans défaut.

Le paradigme de programmation impérative

En programmation impérative (imperative programming), le programmeur écrit une série d'étapes qui doivent être suivies dans l'ordre. Le code source énonce une série précise d'opérations que l'ordinateur doit exécuter dans l'ordre. Puisque l'ordinateur est invité à prendre des actions spécifiques et à exécuter ces instructions, le langage est qualifié d'« impératif ». Un impératif est un ordre ou une commande. Les langages de bas niveau sont des langages impératifs, et les langages de niveau intermédiaire, tels que C, sont impératifs et incluent un autre paradigme. Bien que les langages de bas niveau puissent imiter le style d'un langage structuré, ces propriétés ne sont pas inhérentes au langage lui-même et doivent être imposées par le programmeur comme une pratique. Le code d'assemblage peut facilement être écrit de manière non structurée.

Programmation déclarative et fonctionnelle

Un autre type de programmation, la programmation déclarative (declarative programming), est un paradigme dans lequel le code dicte un résultat souhaité sans spécifier comment ce résultat est atteint. Les langages déclaratifs sont une alternative aux langages impératifs. Dans un langage déclaratif, le programmeur déclare le résultat souhaité, et c'est le travail du compilateur (compiler) de créer une série d'étapes impératives qui obtiennent ce résultat. Par exemple, le Structured Query Language utilisé pour interroger les systèmes de bases de données permet de spécifier quelles données doivent être récupérées d'une base de données, sans spécifier comment le système de base de données doit récupérer ces données.

Les langages fonctionnels sont une autre alternative aux langages impératifs. Rappelons qu'une fonction (function) est un objet (object) mathématique qui définit comment convertir une entrée en une sortie. Par exemple, étant donné x = 4, la fonction $f\text{(}x\text{)}=x+\text{3}$ convertit l'entrée 4 en la sortie 7. Les fonctions peuvent être définies dans la plupart des langages de programmation et correspondent à de petites sections de code qui effectuent une tâche spécifique telle qu'un calcul. Les fonctions peuvent être définies dans la plupart des langages de programmation.

La programmation fonctionnelle est un paradigme de programmation dans lequel les algorithmes sont écrits comme des fonctions mathématiques (Figure 4.10). En programmation fonctionnelle, pratiquement chaque partie du programme est écrite comme une fonction. Le programmeur écrit des fonctions qui convertissent les entrées en sorties, et c'est le travail du compilateur de créer des étapes impératives pour évaluer les fonctions.

Figure 4.10 Ce diagramme montre un exemple de programmation fonctionnelle utilisant Python. Ici, la fonction « LAMBDA » est utilisée pour incrémenter la valeur de x de 1 chaque fois qu'elle est appelée. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Les langages déclaratifs et fonctionnels sont considérés comme des langages de haut niveau car le compilateur crée ces étapes au nom du programmeur. Les langages fonctionnels sont discutés plus en détail dans le Chapitre 7 Langages de programmation de haut niveau.

Programmation structurée

Dans les langages de bas niveau et les premiers langages de haut niveau tels que BASIC (BASIC), certaines instructions spéciales appelées instructions conditionnelles (utilisant « if/then ») et itération (appelées « boucles ») sont programmées à l'aide d'une opération appelée GOTO (GOTO), une opération non structurée qui ordonne à un ordinateur de sauter à une partie entièrement différente du programme. Dans les grands programmes, ces sauts d'un endroit à l'autre interagissent de manière complexe, de sorte que le flux d'exécution est difficile à comprendre lors de la lecture du code. Ces types de programmes sont critiqués pour être du « code spaghetti » désordonné (Figure 4.11).

Figure 4.11 Le même programme qui imprime la racine carrée d'un entier (utilisant SQRT(z)) est présenté dans un format structuré et un format non structuré. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

De nouveaux langages ont été développés pour aider à éviter le code spaghetti. Dans un langage de programmation structurée (structured programming), le flux de contrôle utilise des conditionnelles (par exemple, « if-then ») et des instructions d'itération (par exemple, « while » ou « do while ») et n'utilise jamais d'instructions GOTO. Par exemple, C est un langage structuré qui inclut les instructions conditionnelles « if » et « switch », et les instructions d'itération « for », « while » et « do ». En C correct, toutes les sections de code qui impliquent des conditionnelles et des itérations sont écrites avec ces instructions, et GOTO ne devrait pas être utilisé. Notez que le fait que GOTO soit fourni comme mot-clé dans le langage C est lié au fait que C est un langage de bas niveau et que les programmeurs à ce niveau ont le choix d'utiliser la programmation non structurée si nécessaire, bien que ce ne soit pas recommandé.

L'avantage d'utiliser ces instructions est qu'elles rendent le flux d'exécution clair dans le code source. Lors de l'écriture d'un « if », par exemple, il est clair quel code se trouve à l'intérieur du « if » et quel code se trouve à l'extérieur. Et lors du mélange d'un « if » avec une boucle « for », il est clair si le « if » est à l'intérieur du « while » ou vice-versa. Ces types de relations intérieur/extérieur sont difficiles à percevoir dans le code non structuré. Dans une instruction conditionnelle comme « if », le compilateur exécute une ligne si la condition a été remplie ou est vraie. Sinon, il passe à l'instruction suivante :

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("Enter an input value: ");
        int Val = s.nextInt();
        int Curr_Val = 10;

        if (Val > Curr_Val) {
            System.out.println("The Value that you entered is greater than the current.");
        } else {
            System.out.println("The Current value is greater than the value that you entered.");
        }

    }
}

À l'intérieur d'une boucle, comme « while », les instructions ne sont exécutées que si la condition de la boucle est vraie. Sinon, l'exécution de la boucle se termine, et le compilateur passe aux instructions après la boucle :

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("Enter an input value: ");
        int Val = s.nextInt();
        int Prod = 1;
        
        while (Val != 0) {
            Prod = Prod * Val;
            Val--;
        }
        
        System.out.println("The factorial is " + Prod);
    }
}

Il y a un avantage substantiel à rendre un langage structuré, et le seul inconvénient significatif est que cela rend le langage un peu plus de haut niveau. Par conséquent, parmi les langages de programmation actuellement largement utilisés, tous les langages de niveau intermédiaire et de haut niveau sont structurés.

Programmation procédurale

Dans un langage procédural, chaque partie du programme est une procédure (procedure), qui est une fonction dans le contexte de la programmation. Connue sous le nom de programmation procédurale (procedural programming), c'est un paradigme dans lequel le code est organisé en procédures (Figure 4.12). C'est un sous-type de programmation impérative. Tous les langages procéduraux sont donc impératifs, mais tous les langages impératifs ne sont pas procéduraux. Un programmeur conçoit chaque procédure pour accomplir une tâche spécifique et lui donne un nom descriptif. Cela permet au programmeur de diviser un programme vaste et compliqué en morceaux plus petits et plus gérables, qui sont plus faciles à écrire et plus faciles à comprendre pour les autres programmeurs. Cette propriété du code divisé en petites pièces réutilisables est appelée modularité (modularity), et elle est considérée comme une vertu.

Figure 4.12 Cette comparaison de programmation procédurale met en relation un scénario de la vie réelle, tel que la préparation d'un sandwich, avec la version C++ correspondante du même scénario. Dans les deux cas, chaque étape a sa propre procédure. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

Par exemple, en C, une procédure qui ouvre une socket (socket), ou une connexion Internet entre deux ordinateurs, est appelée g_socket_connect()(Figure 4.13). Cette procédure implique l'exécution d'une série de commandes impératives qui utilisent les fonctionnalités du système d'exploitation, les appels système et le matériel réseau (tels que les cartes d'interface réseau, ou NIC), pour établir une connexion socket. Pour fermer cette connexion et terminer la communication, C (C) utilise la procédure g_socket_close(), qui exécute une série de commandes qui ferment la connexion. Ces procédures utilisent l'approche impérative pour accomplir leurs tâches respectives, de sorte que chaque fonction contient une série d'instructions impératives.

Figure 4.13 Ce diagramme démontre diverses fonctions utilisées par la socket côté client et côté serveur pour établir et fermer une connexion. (source : modification de « Tcp connect » par Sébastien Koechlin/Wikimedia Commons, CC BY 3.0)

Un langage de programmation procédurale (procedural programming) fournit une syntaxe pour définir des procédures mais ne peut pas forcer les programmeurs individuels à diviser leur code en petites procédures et à donner des noms descriptifs aux procédures. Ainsi, même lorsqu'un programme est écrit dans un langage procédural, le code source peut ne pas nécessairement être écrit dans un style procédural.

Programmation orientée objet

Le code orienté objet est organisé autour d'objets. Un objet (object) possède à la fois des données, ou variables, et des procédures qui travaillent ensemble pour représenter un concept humain spécifique. Par exemple, dans une application de bureau ou mobile, chaque bouton à l'écran est un objet. Chaque bouton a des variables pour représenter des informations, telles que l'emplacement et la couleur du bouton, et des procédures qui effectuent des tâches, telles que cliquer, masquer ou afficher le bouton. Ce paradigme de programmation est connu sous le nom de programmation orientée objet (object-oriented programming). C'est un paradigme de programmation dans lequel le code est organisé en objets, où chaque objet a à la fois des données et des procédures. C'est un sous-type de programmation procédurale. Tous les langages orientés objet sont donc procéduraux (et par extension, impératifs), mais tous les langages procéduraux ne sont pas orientés objet. Un exemple simple d'objet peut être un rectangle utilisé pour représenter des concepts significatifs dans la vie réelle, tels que les pièces d'une maison ou une personne ou un robot et ce qu'il peut faire. Différentes pièces peuvent avoir différents attributs, représentant des caractéristiques spécifiques à une cuisine, un salon ou une chambre. Un robot peut avoir un nom et un âge et peut recevoir des commandes d'entrée et répondre ou imprimer un message d'accueil, comme illustré dans la Figure 4.14.

Figure 4.14 L'utilisation orientée objet d'une classe robot instancie des objets robot qui ont les attributs âge, nom et salutation, et les méthodes

input()

,

output()

, et

print()

. (source : Copyright Rice University, OpenStax, sous licence CC BY 4.0)

La programmation orientée objet a été inventée pour aider les programmeurs à organiser leur code, et elle a connu un grand succès. Les langages de haut niveau les plus largement utilisés, y compris C++ (C++), C#, Java, JavaScript et Swift, sont tous orientés objet. La programmation orientée objet est discutée plus en détail dans le Chapitre 7 Langages de programmation de haut niveau.