Programme

Capaticés attendues et commentaires

• Distinguer sur des exemples les paradigmes impératif, fonctionnel et objet.
• Choisir le paradigme de programmation selon le champ d’application d’un programme.

Commentaire : avec un même langage de programmation, on peut utiliser des paradigmes différents. Dans un même programme, on peut utiliser des paradigmes différents.

Paradigmes de programmation

Programmation impérative

• Définition : la programmation impérative est un paradigme de programmation qui décrit les étapes à suivre pour résoudre un problème.
• Exemple : langages C, Python, Java, …

Langages déclaratifs

• Définition : la programmation déclarative est un paradigme de programmation qui décrit le résultat attendu sans décrire les étapes pour l’obtenir.
• Exemple : SQL, Prolog, …

Un langage déclaratif permet d’ecrire la spécification du problème et laisse le soin à l’implémentation de trouver une façon de le résoudre.

En SQL, on décrit le jeu de données, et on demande à la base de données de nous donner les données qui correspondent à notre requête.

Programmation orientée objet

• Définition : la programmation orientée objet est un paradigme de programmation qui permet de décrire des objets et les interactions entre ces objets.
• Exemple : Java, Python, C++, C#…

Les objets sont des entités qui ont des propriétés et des méthodes. Les objets interagissent entre eux en utilisant ces méthodes.

Programmation fonctionnelle

• Définition : la programmation fonctionnelle est un paradigme de programmation qui utilise les fonctions comme élément de base.
• Exemple : Haskell, OCaml, …

La programmation fonctionnelle implique de décomposer un problème en fonctions. Ces fonctions ne possèdent pas d’état interne et ne modifient pas les données (pas d’effet de bord).

Avantages théoriques : preuves formelles plus faciles, parallélisation plus simple, modularité obligatoire, composition de fonctions plus facile.

Exemple : somme des éléments d’une liste

Impératif

def somme(liste):
    s = 0
    for x in liste:
        s += x
    return s
print(somme([1, 2, 3]))

Fonctionnel

On écrit la somme des élément d’une liste de manière récursive.

En Haskell, on utilise une fonction somme qui prend une liste en argument. La somme d’une liste vide est 0. La somme d’une liste non vide est la somme du premier élément plus la somme du reste de la liste (x:xs).

somme [] = 0
somme (x:xs) = x + somme xs
main = print (somme [1, 2, 3])

En python :

def somme(liste):
    if not liste:
        return 0
    return liste[0] + somme(liste[1:])
print(somme([1, 2, 3]))

Objet

En python, on peut définir une classe Liste qui contient une liste et une méthode somme qui calcule la somme des éléments de la liste (= impératif dans un objet)

class Liste:
    def __init__(self, liste):
        self.liste = liste
    def somme(self):
        s = 0
        for x in self.liste:
            s += x
        return s
l = Liste([1, 2, 3])
print(l.somme())

En Java, on peut définir une classe Liste qui contient un tableau d’entiers et une méthode somme qui calcule la somme des éléments du tableau.

class Liste {
    private int[] liste;
    public Liste(int[] liste) {
        this.liste = liste;
    }
    public int somme() {
        int s = 0;
        for (int x : liste) {
            s += x;
        }
        return s;
    }
}

/// Affichage
public class Main {
    public static void main(String[] args) {
        Liste l = new Liste(new int[]{1, 2, 3});
        System.out.println(l.somme());
    }
}

Déclaratif

Prolog : on décrit la somme des éléments d’une liste en Prolog. https://www.tutorialspoint.com/execute_prolog_online.php

La première ligne est le cas de base, la deuxième ligne est le cas récursif. Le cas de base est la somme d’une liste vide, qui est 0. Le cas récursif est la somme d’une liste non vide, qui est la somme du premier élément plus la somme du reste de la liste ([X|Xs]).

:- initialization(main).
main :- somme([1, 2, 3], S), write(S), nl, halt.
somme([], 0).
somme([X|Xs], S) :- somme(Xs, S1), S is X + S1.

Tuto prolog : http://www.gecif.net/articles/linux/prolog.html