Discussion :

[cap_gregg]

Dans Wikipédia, la page consacrée aux paradigmes de programmation recense à ce jour une trentaine de paradigmes :

• programmation impérative
• programmation objet
• programmation logique (Prolog)
• programmation fonctionnelle
• programmation par contrainte
• ...

La mise au point d'un paradigme, et le développement des outils associés (langages, compilateurs, ...) est une oeuvre titanesque, et leurs créateurs sont d'immenses théoriciens et techniciens.

Cependant, parce qu'ils sont immergés dans leur monde et leurs problèmes, ces créateurs ne voient pas les problèmes globalement. C'est pourquoi ces paradigmes restent souvent dissociés (à l'exception de l'Objet qui s'est bien diffusé dans les autres paradigmes).

Prenons un exemple : un langage procédural ne permet jamais d'utiliser les bienfaits de la programmation logique (style Prolog).

Or, en termes de génie logiciel, ces deux paradigmes (procédural et logique) ne sont pas incompatibles 'en soi'. Ce serait même 'très' pratique de pouvoir écrire, en procédural, une chose comme :

SI est_grand_père(a,b)
ALORS liste d'actions procédurales

où la condition est_grand_père(a,b) serait évaluée par inférence.

Sans chercher loin, on voit qu'un rapprochement du procédural et de la logique (par exemple) serait fécond en nouvelles possibilités, par exemple avec des boucles comme :

POUR x TEL QUE est_grand_père("Paul", x)
FAIRE ...

Un autre exemple : le paradigme des tableurs comme Excel est 'très pratique', il suffit de changer la valeur d'une cellule pour que toutes les cellules qui en dépendent soient recalculées automatiquement.

Cependant on ne dispose de ce paradigme dans aucun des 'grands' langages procéduraux ! Ce serait pourtant bien que ces langages permettent de déclarer simplement, une fois pour toutes, que certaines variables sont recalculées automatiquement en fonction d'autres variables.

Les créateurs de langages ne voient pas bien ces besoins, ils en sont assez éloignés. Par contre les utilisateurs de langages les voient bien eux, parce qu'ils ont des contraintes de productivité, de qualité, etc.

En tant qu'utilisateurs, avez-vous d'autres idées où des paradigmes pourraient s'enrichir mutuellement de manière particulièrement pratique ?

[Médinoc]

Je dirais que les "événements" .Net ou "Signaux" de QT correspondent au coup des cases Excel; du moins, le fonctionnement des cases Excel peut être implémenté en ces termes.

[Tommy31]

Prenons un exemple : un langage procédural ne permet jamais d'utiliser les bienfaits de la programmation logique (style Prolog).

Or, en termes de génie logiciel, ces deux paradigmes (procédural et logique) ne sont pas incompatibles 'en soi'. Ce serait même 'très' pratique de pouvoir écrire, en procédural, une chose comme :

SI est_grand_père(a,b)
ALORS liste d'actions procédurales

où la condition est_grand_père(a,b) serait évaluée par inférence.

Le problème est le mélange de nature. "est_grand_père" dans un langage procédural est une fonction, dans un langage logique c'est un prédicat. Dans le premier cas, a et b sont des variables valuées, dans le second cas des variables à valuer. Comment les distinguer ? Par leur type ?

En outre, l'évaluation du premier cas se fait sur la connaissance dans arguments, dans le second sur l'existence d'un ensemble de faits.

Habituellement, quand on a besoin d'une saveur logique, on embarque un moteur d'inférence et on bénéficie de la puissance nécessaire. Dans un langage comme java, il peut y avoir selon les implémentations un continuum entre les 2 univers. De ce fait, il n'y a pas besoin de jouer sur la syntaxe pour y parvenir.

POUR x TEL QUE est_grand_père("Paul", x)
FAIRE ...

Comment tu exprimes tu un fait ou un ensemble de fait ?

Cependant on ne dispose de ce paradigme dans aucun des 'grands' langages procéduraux ! Ce serait pourtant bien que ces langages permettent de déclarer simplement, une fois pour toutes, que certaines variables sont recalculées automatiquement en fonction d'autres variables.

En langage procédural c'est difficile, mais en C++ cela se fait très bien, et cela pourrait se déclarer comme cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
Int a = 5;
Int b = 6;
Int c = a + b; // c est lié par a et b, "dynamiquement"

cout << c; // affiche 11

a =6; 

cout << c; // affiche 12

L'astuce est d'utiliser un type mutable et de faire des compositions de foncteurs reflêtant la séquence des opérations.

[cap_gregg]

Il y a 3 langages (à ma connaissance) qui permettent de mélanger programmation impérative et programmation logique : Oz (nativement), PyPy (nativement), et le C++ (avec le module additionnel Castor).

Or l'intérêt d'utiliser ces 2 paradigmes ensemble est évident, puisqu'il permet (entre autres) aux programmes impératifs d'utiliser des conditions de haut niveau (par ex : SI Est_Risquée(action) ALORS ... ou SI Est_Imposable(x) ALORS ...), ces conditions étant évaluées avec toute la puissance de règles complexes, de bases de faits, et d'un moteur d'inférence.

Nous humains, dans notre manière de penser et d'agir, nous utilisons en permanence ces paradigmes ensemble, de manière naturelle.

Or il n'y a que 3 langages rapprochant ces paradigmes, autrement dit ils sont encore éloignés dans le monde de la programmation.

La question est : y a-t-il d'autres paradigmes, aujourd'hui éloignés, qu'il serait naturel et pratique de rapprocher ?