formations/algo/AlgoApprofondie/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 est 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 technologies
sans aucun recul. Bien 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 langages 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.

Qu'est-ce qu'une machine ?
---------------------------

Une machine, ce truc apparemment si complexe, est en fait
un assemblage de bric et de brac.

L'assemblage des connecteurs permet de simuler un additionneur,
en prenant en compte les propriétés de **reste euclidien**
de l'addition.

La structure électronique est composée de :

- un ordonnanceur.
- le stockage d'un **état**.
- une pile d'instruction

.. glossary::

    adressage

        Dès lors qu'on dispose de ces bases électronique au dessus du processeur,
        un langage d'assemblage est possible, c'est le langage de calcul sur les registres.

    registre

        machines ont un espace mémoire et un espace de calcul (registres)

Un ordinateur, c'est très très stupide, mais ça permet de disposer de :

- une mémoire très grande et ordonnée,
- une capacité à effectuer inlassablement des tâches répétitives
- une grande rapidité de calcul

Apprendre à programmer, c'est-à-dire être capable de
contrôler la machine.

.. important:: Apprendre à programmer, c'est-à-dire apprendre à penser de manière structurée,
               pour pouvoir accessoirement ensuite communiquer avec une machine.

Compilateur
-----------

Schématiquement, un compilateur est un programme qui traduit un
programme d’un langage source vers un langage cible, en signalant
d’éventuelles erreurs.

Quand on parle de compilation, on pense typiquement à la traduction d’un
langage de haut niveau (C, Java, Caml, ...) vers le langage machine d’un
processeur (Intel Pentium, PowerPC, ...)

- xml (libre office, word) -> postscript (imprimante)
- postcript -> image
- syntaxe wiki -> html (Wikipédia...)

compilation graphique

        passer une description, ça donne un dessin genre ocaml Quilt < mon_dessin.txt
        passer par une api qui permet de causer avec une interface

**transpiler** : transformation d'un langage de haut niveau vers un autre
langage de haut niveau.

- cofee script, typescript -> javascript
- (babel) javascript -> javascript ES 6
- python -> javascript

Un compilateur traduit un programme P en un programme Q tel que
pour toute entrée x , la sortie de `Q(x)` soit la même que celle de `P(x)`

Un interprète est un programme qui, étant donné un programme `P` et une
entrée x , calcule la sortie s de `P(x)`

Le compilateur fait un travail complexe une seule fois, pour produire un
code fonctionnant pour n’importe quelle entrée
L’interprète effectue un travail plus simple, mais le refait sur chaque entrée
Autre différence : le code compilé est généralement bien plus efficace que
le code interprété

Typiquement, le travail d’un compilateur se compose d’une phase d’analyse

- reconnaît le programme à traduire et sa signification
- signale les erreurs et peut donc échouer (erreurs de syntaxe, de portée, de typage, etc.)

Puis d’une phase de synthèse

- production du langage cible
- utilise de nombreux langages intermédiaires
- n’échoue pas