formations/algorithmique/cours/fondement.txt

Présentation de l'art de programmer
====================================

Qu'est-ce que la programmation ?
--------------------------------

programmation

    Description d’un calcul (traitement) dans
    un langage compréhensible par la machine
    (langage de programmation)

Le processus d'abstraction
--------------------------

Débuter en programmation n'est pas une chose aisée. Aujourd'hui, la tendance est au
"bas niveau". Souvent, on se jette dans le grand bain :

- soit en s'approchant au maximum de la machine (admin système et réseau, noyau
  linux, langage C)

- soit en faisant du dev web côté backend, ce qui ramène à une administration réseau
  de bas niveau (microservices, monde nodeJS/javascript, etc...)

Soit on suit un cursus scolaire traditionnel qui commence souvent par une
explication du fonctionnement d'une machine abstraite de bas niveau, puis en
allant de plus en plus haut, mais étant sous-entendu qu'il faut rester connecté au
bas niveau (comprendre comment ça se passe derrière la scène).

Dans ces deux cas, il est sous-entendu qu'on apprend plus de choses et plus rapidement en mettant
les mains dans le cambouis, ce qui vrai bien sûr. Mais cela sous-entend qu'un développeur doit
rester le nez dans le guidon. Qu'il doit être un expert de son domaine en accumulant des technos
sans aucun recul. Bie sûr il se doit d'être un expert du système dans lequel il évolue
(connaissance du système d'exploitation, binding avec le C, du ramasse miette (garbage
collector), interaction avec les différentes librairies, gestion et optimisation de la mémoire,
architecture par microservices, threads...) mais il doit aussi être capable de prendre du recul.

L'approche algorithmique (algorithmique de pseudo code, algorithmique algébrique et modulaire)
est un véritable moyen pour le programmeur de prendre du recul : elle commence par se placer du
côté de l'esprit humain et de ses capacités de compréhension et d'abstraction, elle autorise une
pensée rationnelle sur l'art de programmer et permet au programmeur d'effectuer les bons choix,
en connaissance de sa discipline.

Le lien est fait ensuite avec le plus bas niveau grâce une implémentation effective
des langages à partir des paradigmes de rationalisation de la penseée (modules,
objects, généricité, polymorphisme paramétrique...) et d'un outil de communication
avec la machine qu'on appelle compilateur (dont la description est en dehors de
l'objectif de ce cours).

La tendance générale de l'évolution des languages est de se libérer de ces
contraintes de bas niveau, un peu comme en sciences physiques où les lois physiques
dépendent de l'échelle d'en dessous (du niveau microscopique/quantique) mais qu'à
l'échelle du dessus, on n'a pas affaire à des effets de bas niveau (pas d'effets
quantiques à un niveau macroscopique en général). Ce processus d'évolution est vrai
aussi dans le monde de la technique informatique lui-même (modèle OSI, comment est
construite une trame IP, indépendances de chaque couche (transport, payload) entre
elles). Même la tendance système est à la virtualisation qui accentue encore la
tendance à s'affranchir du bas niveau (le niveau système), le séparer nettement du
haut niveau (le niveau applicatif).

Il apparaît régulièrement de nouveaux langages. Comment s'orienter ? Quel(s)
langage(s) choisir pour un projet de développement ? Au delà de leurs disparités, la
conception et la genèse de chacun d'eux procèdent d'une motivation partagée : la
volonté d'abstraire.

- **s'abstraire de la machine** : un langage de programmation permet de
  négliger l'aspect *mécanique* de l'ordinateur. On oublie le modèle du
  microprocesseur, jusqu'au système d'exploitation sur lequel sera exécuté
  le programme.

- **abstraire les erreurs** : Il s'agit ici de garantir la sûreté d'exécution; un
  programme ne doit pas se terminer brutalement ou devenir incohérent en cas d'erreur.
  Un des moyens pour y parvenir est le typage des programmes et la mise
  en oeuvre d'un mécanisme d'exceptions.

- **abstraire le mode opératoire** : Il s'agit de choisir une représentation, un
  paradigme d'implémentation qui est indépendant du domaine considéré (paradigme
  objet, modulaire, générique, composants...)

- **abstraire les composants** : Les langages de programmation donnent la
  possibilité de découper une application en différents composants logiciels, plus ou
  moins indépendants et autonomes. La modularité permet une structuration de plus haut
  niveau de l'ensemble d'une application complexe. Les langages à objets constituent
  une autre approche de la réutilisabilité permettant la réalisation très rapide de
  prototypes.

Description des niveaux d'abstraction par rapport à la machine
---------------------------------------------------------------

Les langages de haut niveau simplifient le travail du
programmeur là où les langages de bas niveau permettent de produire un code
plus efficace.

- **niveau 0** : le langage machine. Illisible, c'est une suite d'optcode.
  impossible de coder dans ce langage.

- **niveau 1** : langage d'assemblage. Il reste très dépendant de la machine
  et aujourd'hui il est rare d'en faire, sauf si on code un bootloader par exemple,
  la gestion de l'accès à la mémoire est en réel (le mode protégé n'apparaît que après).
  Il faut gérer les ressources,le langage est très optimisé mais presque impossible
  à maintenir et rendre générique.  Aujourd'hui plus personne ne code en assembleur.

- **niveau 2** : langages dits de **bas niveau** : (exemple : le C, le C++)
  indépendance par rapport à la machine, grande structuration mais très verbeux

- **niveau 3** : langages dits de **haut niveau** : le raisonnement dans ces
  langages ne dépent plus de la machine, et ils implémentent des paradigmes de
  programmation indépendant de l'état de la mémoire de l'ordinateur,
  ils sont indépendant même du système d'exploitation.