juste une séance... la prof devait me mettre dans un groupe pour une seule séance par semaine de TP du s4...

Bonjour à tous,

Pour ceux qui ne comprennent pas bien pourquoi on vous enseigne la
programmation fonctionnelle, voici un petit article qui explique bien
l'interêt du typage fort et des types algèbriques et qui décrit une
expérience industrielle du langage Ocaml.

http://queue.acm.org/detail.cfm?id=2038036

Cordialement,

XXXXXX XXXXXXX

Le festival du troll est déclaré officiellement ouvert.
Cette année, les profs y participent

Pour les gens qui pensent que le OCaml est moins "puissant" que le C, un
petit benchmark s'impose.
Calculons un terme élevé de la suite de Fibonacci avec les algorithmes
que tous les étudiants aborde au moins une fois, ... dans chaque cours
où il y a du code à écrire.


[Je vous faire grâce de tout le code écrit par l'auteur XD]

Comme nous pouvons le voir, en récursif terminal et itératif, le C et le
OCaml joue sur le même terrain. Par contre, en récursif naïf, OCaml est
sensiblement (largement?) meilleurs.
Cependant, optimisant le stade de compilation pour gcc, option -OX, avec
X allant de 0 à 5 et s, on peut se retrouvé avec des temps plus
intéressant :

[nouvelle grâce]

Ainsi, le récursif naïf est bien plus efficace que avant, plus que le
OCaml. Cependant, pour continuer le troll en faveur de OCaml, nous
pouvons être mauvaise langue et se poser la question si les options se
cachant derrière le -O2 de gcc est possible avec d'autre compilateur
disponible sur le marché.

Bonne journée à tous, et bon week-end.


PS : on pourrais continuer ce troll avec d'autre algorithme qui utilise
des structures de données et des algorithmes plus gourmand.
PSS : un site web faisant des banchmarks avec d'autre langage, et plein
d'autre algo : http://shootout.alioth.debian.org/
PSSS : il y a de plus en plus de bibliothèque logiciel pour agrémenter
OCaml : http://caml.inria.fr//cgi-bin/hump.en.cgi
PSSS : faire du dev web est possible : http://ocsigen.org/ (un peu
difficile à manger cependant, la doc est pas complète malheureusement)
PSSSS :
Les caractéristique de la machine de test (oui c'est old school) :
512Mo de ram.

[grâce d'un autre truc qui sert à rien]

Quoting XXXXX XXXXX <xxxxx.xxxxx@etu.unistra.fr>:

> Le festival du troll est déclaré officiellement ouvert.
> Cette année, les profs y participent

Ah, dans ce cas, voilà de quoi l'alimenter un peu :
http://offres.monster.fr/offres-d-emploi/?q=langage-C&cy=fr
http://offres.monster.fr/offres-d-emploi/?q=OCaml&cy=fr

recherche Keljob (pas d'URL spécifiques?) :
* "C/C++" : 57 résultats ;
* "langage C" : 17 résultats ;
* OCaml : 0 résultat.

Recherches google :
* "C/C++" site:http://www.regionsjob.com (128 résultats)
* "Langage C" site:http://www.regionsjob.com (1 résultat)
* "OCaml" site:http://www.regionsjob.com (0 résultat)

Moralité, le fonctionnel ok, mais dans l'industrie va d'abord falloir
convaincre les décaïdors

-------
en langage C :

// récursif naïf
int fib(int n)
{
if (n == 0)
return 0;
else
if (n == 1)
return 1;
else
return (fib(n - 1) + fib(n - 2));
}

// récursif terminal
int fib_aux(int f0, int f1, int n)
{
if (n == 0)
return f0;
else
if (n == 1)
return f1;
else
return fib_aux(f1, (f0 + f1), (n - 1));
}

int fib(int n)
{
return fib_aux(0, 1, n);
}

// itératif
int fib(int n)
{
int f0 = 0;
int f1 = 1;
int fibo = 1;
int i;

for(i = 1; (i <= (n -1)); i++)
{
fibo = f0 + f1;
f0 = f1;
f1 = fibo;
}

return fibo;
}

//et les instruction du programme principale:
#include <stdio.h>
//code précèdent
int main(int argc, char *argv[])
{
return printf("%d\n", fib(atoi(argv[1])));
}


--------

en OCaml:

(* récursif naïf *)
let rec fib n =
if (n = 0)
then 0
else
if (n = 1)
then 1
else fib(n - 1) + fib(n - 2);;

(* récursif terminal *)
let fib n =
let rec aux f0 f1 n =
if (n = 0)
then f0
else
if (n = 1)
then f1
else aux f1 (f0 + f1) (n - 1) in
aux 0 1 n;;

(* itératif *)
let fib n =
let fibo0 = ref 0 and fibo1 = ref 1 and fibo = ref 1 in
for i = 1 to (n - 1) do
fibo := !fibo0 + !fibo1;
fibo0:= !fibo1;
fibo1:= !fibo;
done;
!fibo;;


(* et les instruction du programme principale: *)
let main () =
let arg = int_of_string Sys.argv.(1) in
print_int(fib arg);
print_newline();
exit 0;;
main ();;


----

la compilation se fera simplement :
ocamlopt <fichier>.ml -o <fichier>
gcc <fichier>.c -o <fichier>

et l'exécution :
time ./<fichier> <nb>

ici, un petit comparatif avec le calcul du 45 em terme de la suite.

rec naïf rec term it
C
real 33.154s 0.002s 0.002s
user 33.124s 0.001s 0.000s
sys 0.021s 0.001s 0.001s

OCaml
real 23.289s 0.003s 0.003s
user 23.261s 0.000s 0.001s
sys 0.021s 0.001s 0.001s

Comme nous pouvons le voir, en récursif terminal et itératif, le C et le
OCaml joue sur le même terrain. Par contre, en récursif naïf, OCaml est
sensiblement (largement?) meilleurs.
Cependant, optimisant le stade de compilation pour gcc, option -OX, avec
X allant de 0 à 5 et s, on peut se retrouvé avec des temps plus
intéressant :
(http://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html)
La plus intéressante des optimisation est la -O2:

rec naïf rec term it
C
real 16.546s 0.002s 0.002s
user 16.443s 0.000s 0.001s
sys 0.002s 0.001s 0.001s

On 30/09/2011 19:37, xxxxxxx.xxxxxx@etu.unistra.fr wrote:

[...]
> Moralité, le fonctionnel ok, mais dans l'industrie va d'abord falloir
> convaincre les décaïdors

Pas de problème. Il suffit de leur expliquer que :
- la STL C++ est entièrement formée de types paramétrés, ce qu'on sait
faire depuis bien longtemps en fonctionnel, par exemple dans OCaml
- la grande nouveauté du C++11, c'est les lambdas, ce qu'on sait faire
depuis bien longtemps dans tous les langages fonctionnels
- d'ailleurs les lambdas, il y en a partout maintenant, y compris en
Javascript (en passant, juste pour dire que c'est quand bien pratique
pour AJAX), même PHP s'y met (ça s'appelle "fonctions anonymes", on peut
faire du PHP sans connaître l'alphabet grec)
- que les constructions fonctionnelles infusent dans la plupart des
langages et systèmes : par exemple 1) les listes en compréhension de
Python, si c'est pas un map avec des lambdas c'est qu'on parle pas de la
même chose, 2) le framework map-reduce de google, c'est de la tisane
tiède pour qui programme en OCaml, 3) C++11 a ajouté un mot-clé,
"constexpr", juste parce que le fonctionnel ça a quand même des
avantages parfois (y compris en termes de performance), 4) que le
"langage" standard de transformation de documents XML, qui s'appelle
XSLT, ça ressemble bougrement à un langage fonctionnel... Il y en a
d'autres.

Normalement, à ce stade-là, votre décideur il arrête de poser des
questions. Si ce n'est pas le cas, il suffit de lui expliquer que
d'après vous, le prochain gros truc que tout le monde va découvrir c'est
le pattern-matching, parce que c'est quand même bien plus général que le
"late-binding" des langages objets. Là c'est sûr, il va changer de sujet
(sauf s'il a fait du *ML dans sa jeunesse).

Faut pas se tromper de débat : on choisit évidemment le langage qu'il
faut pour ce qu'on veut faire, et il y a mille critères pour cela. Mais
la puissance d'un langage, c'est aussi ce qu'il vous apprend sur tous
les autres.

-- AK.

On 30/09/2011 11:24, Wxxxx Wxxxx wrote:
> Le festival du troll est déclaré officiellement ouvert.
> Cette année, les profs y participent
>
> Pour les gens qui pensent que le OCaml est moins "puissant" que le C, un
> petit benchmark s'impose.

Excusez cette comparaison, mais votre message me fait irrésistiblement
penser aux enfants qui reçoivent un beau cadeau mais finissent par jouer
avec l'emballage.

Ce que teste votre "benchmark" est essentiellement la capacité à
manipuler efficacement un pile d'exécution. Il n'y a que ça dans
fibonacci : presque pas de calcul, très peu de données, très peu de
code, pas d'entrées sorties, beaucoup d'appels de fonction. L'idéal pour
les langages comme C, le compilateur peut produire du code qui n'est pas
très loin de l'optimal (le résultat de gcc -O2 est à la fin de ce mesage
si vous ne me croyez pas). OCaml offre de ce point de vue (celui de la
gestion de la pile d'exécution) des possibilités bien plus étendues que
celles de C (par exemple des vraies "lambda"), ce qui bien sûr le
pénalise sur ce genre d'algorithme qui n'en fait pas usage.

Voilà. Si vous pensez que la capacité d'empiler les appels de fonction à
toute vitesse est le critère fondamental, vous avez trouvé votre idéal
de bonheur. Cela dit, l'article cité par Jxxxxx Nxxxxxx donne quatre
critères en faveur de OCaml (selon l'auteur) : la concision, la
correction ("bug detection"), la performance ("within spitting distance
of that of C" :-), le découplage des différentes parties d'un programme
fourni par l'aspect fonctionnel ("Mostly pure"). Je trouve que la
comparaison à Java ou à python est plus éclairante.

-- AK.

P/S: Au fait, le shootout debian précise bien tout ce qu'il ne faut pas
oublier en lisant leur comparaison:
http://shootout.alioth.debian.org/dont-jump-to-conclusions.php#comparison (j'espère
que vous avez noté le "Don't jump to conclusions").

P/P/S: -O4 et -O5 n'ont pas de sens particulier avec gcc, et -Os accepte
de sacrifier de la performance pour minimiser la taille. Vous devriez
ajouter -Ofast, qui est un -O3 accompagné d'options pour le calcul
numérique (en particulier -ffast-math), mais ça ne fera sûrement aucune
différence sur fibonacci...

P/P/P/S: le code produit par gcc -O2 sur un fibo naif (obtenu avec
objdump -d). Il n'utilise la mémoire que pour sa pile (deux push et deux
pop par appel).

[grâce]

Wxxxx Wxxxx <wxxxx.wxxxx@etu.unistra.fr> a écrit :

> Le festival du troll est déclaré officiellement ouvert.
> Cette année, les profs y participent

… et les anciens aussi !

Personnellement je n'ai heureusement pas trop eu à pâtir de CaML, juste le
premier semestre de licence. Simplement je tiens à dire ce que je pense ici.

Je trouve le code CaML est illisible. machin = bidule in truc, les
instructions qui renvoient toutes quelques choses, nécessité de mettre des else
etc. J'ai jamais réussi à l'indenter correctement. Sympa comme premier contact
avec l'informatique pour ceux qui n'auraient jamais touché du code avant.

Ensuite je ne comprends pas ce que vient faire le C ici. Il n'y a pas de
comparaison avec CaML qui tienne à mon sens, si ce n'est que dans certains cas
d'école on peut faire des choses semblables. Rappelez-vous :
the Fundamental Theory of C is "Portable Assembly Language"
On parle d'assembleur, proche de la machine, bas niveau !
… et ce n'est pas parce que certains langages connus comme impératifs reprennent
des avantages du fonctionnel qu'il faut cracher dessus (ni sur l'un, ni sur
l'autre).

En passant, mes petites remarques sur le non-benchmark (ajoutées aux
remarques d'Axxxx Kxxxxxx que je soutiens) :
Quel beau code fonctionnel :
for i = 1 to (n - 1) do
fibo := !fibo0 + !fibo1;
fibo0:= !fibo1;
fibo1:= !fibo;
done;
WTF :
(i <= (n -1))
…et le sensiblement meilleur, qui n'est même pas d'un facteur 2.

J'admets que CaML c'est cool pour la beauté de la chose, que c'est intéressant
de montrer que cela existe, fonctionne. De là à l'enseigner en priorité
(puisque c'est cela le troll, il me semble)…

Je ne parle pas du monde de l'entreprise, comme d'autres car si nous sommes à
la fac c'est pour aller au-delà des problèmes industriels.

Bref, il est plus commode de gaver les p'tits n'étudiants avec de beaux cours
sur des choses bien savantes telles que la programmation fonctionnelle, que
avec du C, c'est sûr. Mais par ailleurs le C a aussi dégoûté plus d'un en
première année dès qu'on a commencé à leur parler de choses bizarres telles que
des "truc qui pointent vers des carrés en mémoire" alors qu'ils ne savaient même
pas ce qu'est la mémoire… qui parle de mettre la charrette avant les bœufs ?

Ce sera tout pour ce vilain troll laineux.

my 2 cents

--
Jxxxxxxx Mxxxxxxx
IT student in Strasbourg

De 11 à 12h, on aurait dû avoir technologie en groupe. Seulement, l'autre groupe n'en avait pas puisque leur professeur était absent. Du coup, mon groupe en avait. Snif. On attendait devant la salle de cours, et on finit par voir notre prof ouvrir la porte.

Prof : Vous êtes contents hein ?
Moi : (-_-)
Un autre élève : Pourquoi ?
Prof : Vous n'avez pas cours
Tous les élèves : OUAIIIIIIIS * courent vers les escaliers *