Présentation d'Objective-Caml
Date de publication : 01/11/2006 , Date de mise à jour : 13/07/2007
I. Introduction
I-1. Un peu d'histoire générale sur les langages fonctionnels
I-2. Pourquoi choisir un langage fonctionnel ?
I-3. Objective Caml
I. Introduction
I-1. Un peu d'histoire générale sur les langages fonctionnels
L'histoire des langages fonctionnels remonte presque aussi loin dans le temps que celle des tous premiers langages de programmation largement diffusés, comme Fortran I ou APL (A Programming Language), le C étant relégué au stade de new-be... autant dire que la descendance est large et parfois même assez complexe, aujourd'hui !
L'histoire de l'informatique retiendra essentiellement quelques langages fonctionnels : Lisp (1958), ML (1970) et Haskell (1990 - héritier de Miranda datant de 1985, lui-même héritier de KRC en 1981 et SASL en 1976). Il s'agit en effet de deux disciplines de programmation entièremenent différentes, bien que possédant des points communs.
L'idée de Lisp était de proposer un langage de programmation permettant de manipuler des listes, structures dynamiques, donnant une très grande souplesse au moment de la conception des programmes, par rapport à ce qui se faisait dans d'autres langages comme les premiers Fortran (tous jusqu'au Fortran 77) qui adoptaient une vision monolithique et statique des structures de données. Le résultat, bien que particulièrement intéressant à l'époque en termes d'abstraction, ne pouvait cependant pas concurrencer directement ce que l'on obtenait grâce aux langages plus classiques, notamment du fait de la forte consommation en termes de mémoire et de temps de calcul des programmes... à une époque où poséder 500 Ko de mémoire vive et une puissance de calcul de 1 MHz était déjà une folie !
ML a suivi cette idée en ajoutant une discipline de typage.
Miranda, moins diffusé mais tout aussi important dans la genèse des langages fonctionnels, proposait une méthode d'évaluation paresseuse d'expressions construites à l'aide d'équations mathématiques. Les expressions, à l'inverse de Lisp, n'étaient pas évaluées lors de l'appel de fonctions, mais uniquement lorsque le corps de la fonction faisait explicitement référence à cette expression, lors de l'exécution du programme. En 1987, Miranda périclita, et a donné naissance à un nouveau langage, beaucoup plus puissant et reprenant tous ses principaux traits : Haskell, qui est aujourd'hui standardisé (Haskell 98) et en très forte expansion y compris dans le monde industriel.
Fondamentalement, on peut ainsi parler de deux branches importantes : les langages dérivés de Lisp (dont Objective Caml, Scheme et Standard ML), et ceux ayant poursuivi dans la voie Miranda (essentiellement le langage Haskell, aujourd'hui). Chaque représentant de chacune des deux branches reprend dans son ensemble à peu près tous les concepts importants des ses ancêtres, en y ajoutant le plus souvent des fonctionnalités tirées des langages impératifs ou orientés objet (comme le fait Objective Caml).
On peut aussi citer quelques langages fonctionnels plus récents, moins classiques mais tout aussi intéressants, puissants et performants : Clean, Erlang (développé par Ericsson pour le parallelisme et la communication) ou encore SCOL.
I-2. Pourquoi choisir un langage fonctionnel ?
On peut affirmer sans trop se tromper que les langages fonctionnels ont mauvaise réputation dans le domaine industriel, bien que les choses sont en train de changer progressivement et dans le bon sens ! Ceci est essentiellement dû au fait que les premières implantations de langages fonctionnels utilisaient des méthode lourdes à l'exécution, faisant ainsi des programmes écrits dans ces langages des "machines à faire ramer l'ordinateur"... Une deuxième raison peut se trouver dans le fait qu'il est nécessaire d'adopter une attitude différente lorsque l'on aborde la programmation fonctionnelle : certains langages étant purs et ne possédant pas de notions de boucles (boucles for ou while), il n'est pas rare de trouver des personnes complètement désorientées par le système, lâchant tout de suite l'affaire.
Du côté des performances, les choses ont bien changé avec l'apparition des compilateurs natifs : dès lors, il arrive que des programmes écrits en Haskell, en Objective Caml ou en Clean rivaliser en termes de performances des programmes faits en C, ADA ou Fortran !
Du côté de l'apprentissage des langages fonctionnels, on peut remarquer à juste titre que le développement d'internet a permis une divulgation massive des connaissances et l'on voit fleurir un peu partout des tutoriels comme celui-ci, ou encore des forums d'aide.
En ce qui concerne le monde académique et le monde de la recherche, il existe une véritable demande pour les langages fonctionnels ; celà mène à dire, sans trop se tromper, que les langages fonctionnels sont un excellent moyen de prototypage d'applications. A titre d'exemple, un rapport d'enquête mené à l'université de Yale aux Etats-Unis et portant sur les possibilités en termes de développement de différents langages (entre autres ADA, C ++, Ruby et Haskell) montre très clairement que l'utilisation d'un bon langage fonctionnel, dans ce cas, Haskell, permet de développer très rapidement en 80 lignes de code un application qui en C ++ en fait 1100, et avec un temps d'exécution supérieur. Il est donc intéressant d'utiliser un langage fonctionnel pour écrire assez rapidement une première version d'une application, afin d'évaluer de façon plus précise les contraintes, ce qui peut grandement améliorer le développement de l'application finale, étant donné que bon nombre de difficultés seront déjà apparues et/ou résolues lors de l'élaboration du prototype.
Il est cependant une chose qu'il faut garder à l'esprit : chaque langage de programmation possédant son propre mode de fonctionnement, il est inutile de vouloir plaquer sur un code Haskell, par exemple, un schéma Fortran, ADA ou Java. La programmation fonctionnelle est avant tout un style de programmation privilégiant l'abstraction et il est important, dès lors, de prendre un peu de recul par rapport au problème et à l'algorithme à implanter afin de pouvoir écrire le code facilement. Les compilateurs de langages fonctionnels ont aussi, pour la plupart, une notion assez fine de la sémantique d'un programme, de sorte qu'il est parfois inutile de croire que prendre de la hauteur au niveau du code se traduira inexorablement par une perte sèche en termes de performances.
I-3. Objective Caml
Objective Caml fait partie de la branche Caml de la famille ML (Meta Language), l'une des familles des descendants de Lisp. La première version de ML était dédiée à programmer la recherche automatique de preuves dans un système d'aide à la démonstration (de théorèmes mathématiques) du système LCF (Logic for Computable Functions). ML est ensuite apparu comme un langage généraliste, et a été étendu en ce sens, indépendamment de LCF. Il est aujourd'hui le plus important représentant. Parallèlement à la branche Caml on trouve la branche SML (Standard ML) avec SML/NJ et mossml, essentiellement des langages anglo-saxons.
Caml est l'acronyme de Categorical Abstract Machine Language, qui pourrait se traduire par "langage informatique abstrait typé"... En fait, il s'agit surtout de la combinaison, proposée par Guy Cousineau, des mots CAM (Categorical Abstract Machine, une machine virtuelle issue de travaux de Pierre-Louis
Curien sur la sémantique des langages fonctionnels) et ML (Meta Language).
Caml voit le jour en 1986 : il s'agit d'un projet reposant sur Le_Lisp et développé par l'INRIA en collaboration avec l'Ecole Normale Supérieure et l'Université Paris 7, et utilisé à la base en tant que support à l'implantation d'un système de preuve de programmes, connu aujourd'hui sous le nom de Coq. Son nom est tiré du nom de sa machine virtuelle appelée CAM (acronyme de Categorical Abstract Machine). Une machine virtuelle est un programme permettant d'exécuter des instructions binaires écrites dans un format le plus souvent indépendant du système d'exploitation et du processeur utilisé. En réalité, la machine virtuelle émule complètement le fonctionnement d'un ordinateur et d'un système d'exploitation, permettant ainsi au code binaire d'être portable. Java est construit sur le même principe, d'où, entre autres, son succès.
Au début des années 1990, Xavier Leroy écrit une nouvelle machine virtuelle appelée Zinc (acronyme récursif de Zinc Is Not Caml, afin de montrer explicitement que ces deux langages partagent moins de choses qu'il n'y paraît), autorisant une multitude d'opérations interdites avec la CAM. Ce projet donne naissance à Caml-Light, très utilisé malheureusement dans l'enseignement supérieur en France, puis à Caml Special-Light, la première implantation possédant un compilateur natif (c'est-à-dire produisant un code assembleur exécutable directement, sans passer par le machine virtuelle). La première version d'Objective Caml voit le jour en 1996 et apporte une couche objet au langage, lui permettant d'être extrêmement générique.
Aujourd'hui, Caml-Light et Caml Special-Light sont des projets arrêtés, la dernière mise-à-jour de Caml-Light datant de 2002 ; seul Objective Caml est activement développé par l'équipe CRISTAL de l'INRIA et disponible pour un très grand nombre d'architectures et de systèmes d'exploitation : Linux, Windows (pas moins de trois versions), Solaris, Iris, HP-Unix, FreeBSD, etc... pour les systèmes et IA32, IA64, x86_64, Dec Alpha, UltraSparc, PA-Risc, PowerPC, ARM, MIPS, etc... en ce qui concerne les architectures.
Il suffit de trois expressions pour décrire l'essence même du langage Objective Caml : "langage fonctionnel", "strict", "fortement typé".
- langage fonctionnel : on peut programmer sans effets de bords, c'est-à-dire sans modifier silencieusement l'environnement d'exécution du programme (une affectation ou une saisie au clavier sont des effets de bords), et les fonctions sont traitées comme des valeurs à part entière que l'on peut passer en argument, faire retourner par d'autres fonctions, etc...
- strict : tous les paramètres des fonctions sont évalués avant de rentrer dans le corps de la fonction en elle-même.
- fortement typé : l'inférence de types pour les fonctions et les expressions est faite à la compilation, de sorte que beaucoup d'erreurs pouvant apparaître dans d'autres langages lors de l'exécution sont éliminées dès la compilation. Il s'agit en effet d'un gage de sûreté de développement important.
En outre, Objective Caml est extrêmement expressif, essentiellement parce qu'il contient tous les traits des autres langages de programmation classiques :
- expressions paresseuses encapsulées dans des valeurs d'un type particulier, dont les flots de données
- boucles for et while et structures de données modifiables, autorisant ainsi les effets de bord
- une couche objet autorisant, entre autres, l'héritage multiple
- un langage de modules surpuissant permettant de créer des foncteurs, sorte de fonctions construisant un module à partir d'autres modules
- un pré-processeur, Camlp4, reléguant au stade d'antiquité celui du C ; on peut ainsi construire soi-même ses propres extensions du langage en définissant des extensions de la grammaire actuelle, ou encore se servir du pré-processeur en tant que générateur d'analyseurs syntaxiques dynamiques et reconnaissant une classe de grammaires plus large que celle reconnue par ocamlyacc (l'équivalent de Yacc en Objective Caml), c'est-à-dire permettant de faire évoluer la définition d'une grammaire au cours de l'exécution en modifiant des règles, etc... D'ailleurs, une syntaxe révisée de tout Objective Caml a été écrite grâce au pré-processeur et le pré-processeur lui-même est écrit en partie dans cette syntaxe révisée !
- machine virtuelle autorisant le chargement dynamique de code
- nombreux autres utilitaires
Ces derniers points associés à la présence d'une machine virtuelle, issue de la Zinc, munissent le langage d'un attrait indéniable : portabilité, ré-utilisabilité massive non seulement de code mais aussi de binaires, facilité de développement, etc...
Suivez-donc la voie du chameau !
 |
Pour plus d'infos sur l'histoire de Caml, suivez le lien...
|
 |
Pour infos, il existe un langage proche d'OCaml et fonctionnant sur la machine virtuelle .Net, nommé F#
Suivez le lien...
|
Copyright (c) 2006-2007 Antonio Pasinelli, Nicolas Vallée.
Permission is granted to copy and distribute under the terms of the Creative Commons licence, Version 3.0 or any later version published by the Creative Commons Corporation; with Attribution, No Commercial Use and No Derivs. Read the full license here : http://creativecommons.org/licenses/by-nc-nd/3.0/legalcode
