# Outils

* Atom (plugin: script)
* Eclipse (2019-06)
* OpenJDK 11

# Liens

* https://algo.developpez.com/tutoriels/initiation/
* ftp://ftp-developpez.com/marcel/cours-architecture.pdf
* https://marcel.developpez.com/cours/systeme/architecture-ordinateur/
* https://hdd34.developpez.com/cours/artpoo/
* https://www.jmdoudoux.fr/accueil_java.htm

# Thèmes

* Algorithmique
* Langages (haut/bas niveau, interprétés, VM, shell, objet)
* Fonctionnement CPU (instructions, registre, adresse, assembleur)
* Mémoire (pile, tas, pointeur)
* Langage C (allocation, chaines, pointeur, erreurs)
* OS
* Réseau (couches, TCP/IP, HTTP)
* Java (base du langage, classes, interfaces, Collections, generics, streams)

# Algorithmique

## Définitions

Un **algorithme** est une procédure de calcul bien définie qui prend en entrée un ensemble de valeurs et qui délivre en sortie un ensemble de valeurs.

Une **structure de données** est un moyen de stocker et d'organiser des données pour faciliter leur stockage, leur utilisation et leur modification.

L'**efficacité** d'un algorithme est mesurée par son coût (**complexité**) en temps et en mémoire.

La complexité d'un algorithme est :

* en temps, le nombre d'opérations élémentaires effectuées pour traiter une donnée de taille n ;
* en mémoire, l'espace mémoire nécessaire pour traiter une donnée de taille n.

[Courbes](https://algo.developpez.com/tutoriels/initiation/#LV-D)

Les instructions élémentaires sont : addition, multiplication, modulo et partie entière, affectation, instruction de contrôle.

Un **type abstrait** est un triplet composé :

* d'un nom
* d'un ensemble de valeurs
* d'un ensemble d'opérations définies sur ces valeurs.

Les types abstraits de base de l'algorithmique sont :

* entier (`int`)
* caractère (`char`)
* booléen (`boolean`)
* réel (`double`)

Une **variable** est un triplet composé :

* d'un type (déjà défini)
* d'un nom (a priori toute chaîne alphanumérique)
* d'une valeur

La **déclaration** d'une variable est une instruction qui permet de définir dans le programme le nom et le type de la variable. L'**initialisation** permet de donner une première valeur à cette variable. Lorsqu'une variable n'est pas initialisée, elle a une valeur vide particulière notée `null` (en java).

Les **expressions** sont constituées à l'aide de variables déjà déclarées, de valeurs, de parenthèses et d'opérateurs du (des) type(s) de variables concernées. Une expression a une valeur qui peut être utilisée par une instruction.

L'**affectation** est l'instruction qui permet de stocker une valeur dans une variable.

**Evaluer** une expression ou une variable consiste à déterminer sa valeur courante.

## Types de base

### Booléens

Une variable de type booléen prend comme valeur VRAI (`true`) ou FAUX (`false`). Les opérations usuelles sont ET (`&&`), OU (`||`) et NON (`!`) qui sont données dans les tables qui suivent :

![OU](https://algo.developpez.com/tutoriels/initiation/images/10000000000000F000000047A81967DE0AE0CFB7.gif)

![ET](https://algo.developpez.com/tutoriels/initiation/images/10000000000000F00000003CD94585357F59CD48.gif)

![NON](https://algo.developpez.com/tutoriels/initiation/images/10000000000000A70000003C6EB52D563A7241F9.gif)

### Entiers

Une variable de type entier peut prendre comme valeur l'ensemble des nombres entiers signés. Les opérations associées sont les opérations usuelles `+`, `-`, `*`, `/`.

### Réels

Une variable de type réel peut prendre comme valeur l'ensemble des nombres réels. Les opérations associées sont les opérations usuelles `+`, `-`, `*`, `/`.

### Caractères

Une variable de type caractère peut prendre comme valeur l'ensemble des caractères imprimables. On notera les valeurs entre apostrophe (`'`, quote). On considère souvent que les caractères sont ordonnés dans l'ordre alphabétique.

### Chaines de caractères

Une variable de type chaine de caractères peut prendre comme valeur toute suite de caractères (y compris vide). On notera les valeurs entre guillemets (`"`, double quote). Le type en java est noté **`String`**. L'opération `+` permet de concaténer (fusionner) des chaines de caractères.

    "Hello" + "World"

    "HelloWorld"

### Attention

Les valeurs :

* `"1"` qui est une chaine de caractères
* `'1'` qui est un caractère
* `1` qui est un entier
* `1.0` qui est un réel

sont différentes et ne seront pas codées de la même manière dans la mémoire de la machine.

### Comparaison

Les opérateurs `<`, `<=`, `==`, `!=`, `>`, `>=` permettent de comparer les valeurs de type entier, réel et caractère. Le résultat de cette comparaison est une valeur booléenne.

## Structure de contrôle

Il y a trois structures principales de contrôle qui permettent de construire des algorithmes.

### Bloc d'instructions

    {
      instruction1;
      instruction2;
      ...
    }

### Alternative/condition

    if (expression) 
      bloc1

Les instructions du bloc _bloc1_ sont exécutées si _expression_ a une valeur booléenne vraie.

    if (expression)
      bloc1
    else
      bloc2

Les instructions du bloc _bloc1_ sont exécutées si _expression_ a une valeur booléenne vraie, les instructions du _bloc2_ sinon.

    switch (variable) {
      case valeur1:
        bloc1
        break;
      case valeur2:
        bloc2
        break;
      ...
      default:
        bloc3
    }

Les instructions du _bloc1_ sont exécutées si la variable a la valeur _valeur1_, du _bloc2_ si la variable a la valeur _valeur2_, du _bloc3_ dans les autres cas.

### Répétition/boucle

    while (expression)
      bloc

Si _expression_ a une valeur booléenne vraie, les instructions de _bloc_ sont exécutées. Cet enchainement se reproduit tant que _expression_ est vraie. Une **boucle infinie** se produit lorsque l'expression ne devient jamais fausse.

    do
      bloc
    while (expression)

Similaire au cas précédent, mais le bloc d'instructions est exécuté avant l'évaluation de l'expression. Par conséquent, ce bloc est exécuté au moins une fois.

    for (initialisation; expression; incrementation)
      bloc

Le bloc d'instructions _bloc_ est exécuté tant que _expression_ a une valeur booléenne vraie. Une variable peut être initialisée par l'instruction _initialisation_ et incrémentée par l'instruction _incrémentation_. Exemple:

    for (int i = 0; i < 10; i++) {
      // boucle sur les entiers de 0 à 9
    }

## Fonctions

Une **fonction** est une section d'algorithme qui a un objectif bien défini et un nom. En général, elle communique avec l'extérieur par le biais de paramètres typés. Elle possède des variables locales qui ne sont pas visibles à l'extérieur de la fonction. Une fonction peut retourner un résultat.

Une fonction est **exécutée** (ou appelée) lorsqu'on l'utilise dans une instruction en lui définissant les paramètres requis par sa définition. Les fonctions qui retournent une valeur peuvent également être utilisées dans une expression.

Exemples:

### Définition d'une fonction sans paramètres et ne retournant pas de valeur

    void maFonction() {
      // instructions
    }

### Définition d'une fonction avec paramètres et ne retournant pas de valeur

    void maFonction(int i, char c) {
      // instructions
    }

### Définition d'une fonction avec paramètres et retournant une valeur

    int maFonction(int i) {
      return i + 1;
    }

### Appel d'une fonction sans paramètres

    maFonction();

### Appel d'une fonction avec paramètres

    char variable = 'a';
    maFonction(1, variable);

### Appel d'une fonction dans une expression

    if (maFonction(0) > 1) {
      // instructions
    }

# Structures de données

## Tableaux

Un **tableau** (array) est une structure de données ordonnée, contenant un nombre invariant de valeurs du même type. L'accès aux valeurs contenues se fait par un indice (numéro d'ordre parmi les éléments du tableau, en commençant à 0). L'affectation des éléments du tableau peut se faire à l'initialisation ou en utilisant les indices.

### Déclaration d'un tableau de 4 éléments

    int[] tab = new int[4];

### Déclaration et initialisation

    int[] tab = new int[] { 1, 2, 3, 4};

### Affectation des éléments

    int[] tab = new int[4];
    tab[0] = 1;
    tab[1] = 2;
    tab[2] = 3;
    tab[3] = 4;

### Accès aux éléments

    if (tab[0] > 0) {
      // instruction
    }

## Liste

Une **liste** est une structure similaire à un tableau mais de taille variable.

    List maList = new ArrayList();
    maList.add(1);
    maList.add(2);

    int variable = maList(1); // variable vaut 2

## Ensemble

Un **ensemble** (set) est une structure de données non ordonnée contenant des éléments uniques.

    Set ensemble = new HashSet();
    ensemble.add(1);
    ensemble.add(2);
    ensemble.add(2); // pas d'effet car les éléments sont uniques

## Table d'association

Une **table d'association** (dictionnaire, map) est une structure de données contenant des valeurs indexées par une autre valeur appelée clé. On peut accéder à une valeur en utilisant sa clé, on peut affecter une valeur en fournissant la clé et la valeur.

    Map tableAssoc = new HashMap();
    tableAssoc.put(1, "un");
    tableAssoc.put(2, "deux");

    // valeur pour la clé 1
    tableAssoc.get(1);

## Structure/Objet

Une structure est un type de données contenant plusieurs valeurs nommées. On appelle le nom d'une valeur dans une structure un attribut. On peut accéder à la valeur d'un attribut en utilisant l'opérateur `.`. Dans les langages dit "objet", la notion de structure est remplacée par la notion d'objet qui est une forme de structure contenant également des fonctions.

    class MonObjet {
      int monAttributEntier;
      String monAttributChaine;
    }

    MonObjet obj = new MonObjet();
    // affectation des attributs
    obj.monAttributEntier = 1;
    obj.monAttributChaine = "test";
    // valeurs des attributs
    if (obj.monAttributEntier > 0) {
      // instruction
    }

# Langages

## Définition

On appelle __langage informatique__ un langage destiné à décrire l'ensemble des actions consécutives qu'un ordinateur doit exécuter. Un langage informatique est ainsi une façon pratique pour nous (humains) de donner des instructions à un ordinateur. 

## Types de langages

### Machine

Le **langage machine** est celui utilisé par le processeur. Il s'agit d'une succession de données binaires (0, 1) transmises sous forme d'impulsions électriques. Ce langage n'est pas directement compréhensible par l'être humain, il est donc nécessaire de disposer de langages de programmation intermédiaires. Le code dans ces langages est transformé en langage machine pour être exploité par le processeur.

### Assembleur

Un **langage assembleur** est un langage très proche de la machine, utilisant des mots clés et des notations compréhensibles par un être humains pour représenter des instructions, des données et des adresses mémoires.

Ce type de langage ne permet pas d'écrire un code portable, car le jeu d'instruction est propre á chaque type de processeur. Il y a donc un langage assembleur pour chaque type de processeur.

Le terme __portabilité__ désigne l'aptitude d'un programme informatique a être utilisé sur des machines de types différents.

De plus, la simplicité des instructions de base d'un processeur rend l'écriture des programmes complexe et très longue.

### Compilé/interprété

Un programme écrit dans un **langage interprété** a besoin d'un programme auxiliaire (l'interpréteur) pour traduire au fur et à mesure les instructions du programme. 

Un programme écrit dans un **langage compilé** va être traduit une fois pour toutes par un programme annexe, appelé compilateur, afin de générer un nouveau fichier qui sera autonome, c'est-à-dire qui n'aura plus besoin d'un programme autre que lui pour s'exécuter; on dit d'ailleurs que ce fichier est **exécutable**. Cet exécutable n'est cependant valable que pour un seul type de processeur et de système d'exploitation.

Certains langages utilisent une approche intermédiaire basée sur une machine virtuelle (java par exemple). Le code est compilé dans un pseudo langage machine (bytecode) qui n'est pas directement exécutable par un processeur. Pour l'exécuter, on utilise un interpréteur qui simule un processeur capable d'exécuter le bytecode. Ce type de langage permet de profiter d'une bonne portabilité sans souffrir des problèmes de performance des langages interprétés.

### Bas niveau/haut niveau

Les langage sont classés de bas vers haut niveau selon la proximité avec le langage machine. Les langages assembleurs sont ceux de plus bas niveau. Le **langage C** est un langage de bas niveau car il nécessite (et permet) de gérer manuellement la mémoire (allocation pour stocker des variables, libération, pointeurs) et la communication avec les périphériques. Les langages dit de haut niveau (Java, Python, Go) permettent de se libérer de ces contraintes et de produire plus rapidement des logiciels aux fonctionnalités avancées.

### Procédural/objet

La **programmation procédurale** est un paradigme qui se fonde sur le concept d'appel procédural.  Une procédure, aussi appelée routine, sous-routine ou fonction, contient simplement une série d'étapes à réaliser. N'importe quelle procédure peut être appelée à n'importe quelle étape de l'exécution du programme, y compris à l'intérieur d'autres procédures, voire dans la procédure elle-même (récursivité). 

La **programmation objet** consiste en la définition et l'interaction de briques logicielles appelées objets ; un objet représente un concept, une idée ou toute entité du monde physique, comme une voiture, une personne ou encore une page d'un livre. Il possède une structure interne et un comportement, et il sait interagir avec ses pairs. Il s'agit donc de représenter ces objets et leurs relations ; l'interaction entre les objets via leurs relations permet de concevoir et réaliser les fonctionnalités attendues, de mieux résoudre le ou les problèmes. Dès lors, l'étape de modélisation revêt une importance majeure et nécessaire pour la POO. C'est elle qui permet de transcrire les éléments du réel sous forme virtuelle. 

### Langages spécialisés

Certains langages sont dédiés à la manipulation de données (lecture, création, modification) et ne permettent pas de réaliser des algorithmes complexes. Il sont dépendant d'un logiciel tiers ou d'un format de données particulier. Exemples: SQL, Xpath

D'autres langages sont utilisés pour la création de documents (HTML) ou la mise en page (CSS).

Certains langages sont dit "embarqués", car ils ne sont pas exécutés directement sur le processeur mais au sein d'un autre logiciel (par exemple javascript dans un navigateur).