FIXME
======

Qu'est-ce qu'un programme ?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

- Un programme est une suite de phrases
- Une phrase est une **déclaration** ou une **expression**.
- Le signe "égal" est utilisé lorsqu'une une déclaration ou une expression sont équivalentes

Les déclarations
----------------

Renseigner une variable


- en javascript :

.. code-block:: javascript

    var b = "blabla" ;

- en python :

.. code-block:: python

    b = "blabla"

- en java :

.. code-block:: java

    String b = "A";

- en OCaml :

.. code-block:: ocaml

    let a = 1

(**let** : soit `a` la variable... )

En OCaml comme dans tous les langages fonctionnels, toutes les "variables"
(les affectations) sont en fait des **constantes**.

.. important::

    Par voie de conséquence, le symbole ``=`` est utilisé à la fois pour la définition des objets et pour le test d'égalité.
    Pour les autres langages, on utilise `==` ou bien `===` (javascript) car
    le `=` est sémantiquement déjà utilisé...

Toutes ces notation, apparemment anodines, correspondent donc à des paradigmes de programmation

Lorsqu'on ne déclare pas les types des symboles déclarés, c'est que soit

- le typage est faible
- le typage est dynamique (calcul du type en fonction du contenu de la
  variable)
- le typage est statique et fort mais ça ne se voit pas
  (var le système les calcule automatiquement par inférence de type)

Assigner, allouer, affecter une chose à quelqu'un ou à une autre chose.

Exemples dans la langue française :

- Le traitement que le budget **alloue** à ces fonctionnaires.
- Un système d'exploitation multitâche alloue le travail du processeur aux processus en attente, pour un bref laps de temps, à leur tour.

.. glossary::


    affectation

        une affectation, aussi appelée assignation par anglicisme, est une structure qui permet d'attribuer une valeur à une variable.

        Il s'agit d'une structure particulièrement courante en programmation impérative, et dispose souvent pour cette raison d'une notation courte et infixée,
        comme ``x = expr`` ou ``x := expr`` ou encore `x <- expr`.
        Dans certains langages, le symbole est considéré comme un opérateur d'affectation,
        et la structure entière peut alors être utilisée comme une expression.
        D'autres langages considèrent une affectation comme une instruction et ne permettent pas cet usage.

Voir aussi :

- Déclarations de types primitifs et conversions de type
- Tpes de base::

        Octets (8 bits) byte
        Entiers courts (16 bits) short
        Entiers (32 bits) int
        Entiers longs (64 bits) long
        Réels (32 bits) float
        Réels longs (64 bits) double
        Caractères (16 bits) char
        Booléens boolean

- Déclarations par lots::

    x1 = e1, x2 = e2, ... xn = en;

Les fonctions
-------------

Préliminaire : rappel de théorie de l'information
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Théorie de l'information (Claude Shannon, 1949), théorie de la
communication

canal de transmission::

    entrée -> récepteur -> émetteur -> sortie

Description d'une procédure
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

- une procédure peut prendre des paramètres
- elle modifie l'état courant du système

- Déclaration des paramètes
- Déclaration du corps
- Appel

procedure permuter(a: int, b:int)
  z: int
  begin
    sdfdsfsdfsd
  end


effet de bord

    toute modification de la mémoire ou modification d'un support externe

instruction

    command/phrase en mesure de modifier l'état du programme ou de la machine hôte
	(allocation mémoire, support externe, disque, écran...)

Une procédure ne renvoie pas de valeur, mais provoque un 'effet de bord' (écriture dans une globale, dans un flux sortant etc.).

Une procédure permet de créer une instruction nouvelle qui deviendra une primitive pour le programmeur
Cela permet de structurer le texte source du programme et améliorer sa
lisibilité. Cela permet aussi d'appeler plusieurs fois, et à plusieurs endroit
dans le code, cette primitive.

.. **FIXME** : exemple avec un goto

Appel d'une procédure
~~~~~~~~~~~~~~~~~~~~~

(ex: pseudo-pascal)

**déclaration de procédure**

::

    procedure p(x1, ..., xn);
        var v1,...,vm;

- les variables x1,...,xn sont appelées *paramètres formels* de p
- les variables v1,...,vm sont appelées *les variables locales* de p

**appel de procédure**

::

    p(e1, ..., en)

les expressions e1,...,en sont appelées paramètres effectifs de p

::

    program syracuse;
    procedure syracuse(max : integer);
    var i : integer;
        procedure length();
        var v,j : integer;
            procedure step();
            begin
                v := v+1; if j = 2*(j/2) then j := j/2 else j := 3*j+1
            end;
        begin
            v := 0; j := i; while j <> 1 do step(); writeln(v)
        end;
    begin
        i := 1;
        while i ≤ max do begin length(); i := i+1 end
    end;

    begin syracuse(100) end.


Le niveau d’une déclaration (de variable ou de procédure) est le nombre
de procédures sous lesquelles elle est déclarée. Le programme principal
a le niveau 0.

Description d'une fonction
~~~~~~~~~~~~~~~~~~~~~~~~~~

Une fonction renvoie une valeur et ne modifie pas l'état courant du programme
en cours d'exécution ni ne réalise d'effets de bord. Elle renvoie
**toujours** quelque chose (même la valeur ``None`` qui n'est pas rien)