Hello everyone,
I don't know if there are French speakers lurking on this group, but
I'd really appreciate if somebody could make sure that my translation
of the Clojure rationale is accurate and typo-free.
Clojure
=======
Clients et investisseurs ont des investissements substantiels dans les
plate-formes standards utilisées en industrie, telles que la JVM, et
sont
confortables avec leur performance, leur stabilité et leur sécurité.
Même
s'ils envient la brièveté, la flexibilité et la productivité des
langages
dynamiques, les programmeurs Java ont des soucis de compatibilité avec
l'infrastructure des clients, d'accès aux bibliothèques et modules
déjà
existants et de performance avec lesquels ils doivent composer. De
plus, ils
font face chaque jour à des problèmes en lien à la concurrence dûs à
l'utilisation de threads et de verrous. Clojure est un effort pour
créer un
langage dynamique et pragmatique dans ce contexte. Il vise à être un
langage
à usage général qui est adapté à toutes les tâches pour lesquelles
Java est
utilisé. Il reflète également la réalité que, dans un contexte de
programmation concurrente, la mutation omniprésente et incontrôlée des
valeurs
doit être éliminée.
Clojure atteint ses buts en se jumelant à une plate-forme utilisée en
industrie, la JVM; en modernisant un langage vénérable, Lisp; en
encourageant
la programmation fonctionnelle via des structures de données immuables
et
persistantes; et en offrant un support de première classe pour la
concurrence
via un système de mémoire transactionnelle (software transactional
memory, STM)
et des agents asynchrones. Le résultat est un langage robuste,
pratique et
rapide.
Pourquoi Clojure?
-----------------
Pourquoi ai-je écrit un nouveau langage de programmation? Parce que
je
voulais:
* Un Lisp
* Adapté à la programmation fonctionnelle
* En symbiose avec une plate-forme établie
* Créé pour la concurrence
Et je n'en trouvais aucun. Voici un aperçu de quelques unes des idées
derrière Clojure.
Lisp est une bonne chose
------------------------
- Souvent émulé et pillé, jamais dupliqué
- Le calcul lambda produit un noyau très petit
- Presque pas de syntaxe
- Les avantages principaux sont encore que le code est du data et les
abstractions syntaxiques
- Pourquoi pas un Lisp standardisé?
- Innovation lente ou inexistante suite à la standardisation
- Les structures de données fondamentales sont modifiables et
non-extensibles.
- La concurrence n'est pas adressée dans les spécifications
- De bonnes implémentations existent déjà pour la JVM (ABCL, Kawa,
SISC)
- Les Lisps standards sont leur propre plate-forme
- Clojure est un Lisp qui n'est pas contraint par la rétro-
compatibilité
- Étend le paradigme de code-is-data aux vecteurs et aux maps
- Les structures de données fondamentales sont immuables
- Les structures de données fondamentales sont des abstractions
extensibles
- Adopte une plate-forme existante (JVM)
La programmation fonctionnelle est une bonne chose
--------------------------------------------------
- Données immuables et fonctions de premier ordre
- La programmation fonctionnelle est possible dans Lisp, mais par
convention
et discipline
- Si une structure de données est modifiable, il est dangereux de
présumer
qu'elle ne le sera pas
- Dans les Lisps traditionnels, seule la liste est
structurellement
récursive
- Les langages de programmation fonctionnelle purs sont habituellement
typés
statiquement
- Pas idéal pour tout le monde ou dans tous les cas
- Clojure est un langage fonctionnel avec une emphase sur le dynamisme
- Toutes les structures de données sont immuables, persistantes et
sont
structurellement récursives
- Collections et types de retour hétérogènes
- Polymorphisme dynamique
Langages et plate-formes
------------------------
- Les machines virtuelles, pas les systèmes d'exploitation, sont les
plate-formes du futur. Elles offrent:
- Des systèmes de types
- Des bibliothèques
- Abstraites du systèmes d'exploitation
- *Énorme* ensemble d'accessoires
- Bibliothèques standards et externes
- La gestion de la mémoire et d'autres ressources
- Un ramasse-miettes est un accessoire de la plate-forme, pas
du
langage
- Bytecode et compilation JIT
- Abstraits du matériel de l'ordinateur
- Langage en tant que plate-forme vs. langage + plate-forme
- Ancienne méthode: chaque langage défini son propre support
d'exécution
- Ramasse-miette, bytecode, systèmes de types, bibliothèques,
etc.
- Nouvelle façon (JVM, .NET)
- Le support d'exécution est indépendant du langage
- Langage construit pour une plate-forme vs. langage porté à une plate-
forme
- Bon nombre de nouveaux langages adoptent la philosophie "le
langage est
la plate-forme"
- Quand ils sont portés vers une autre plate-forme, ils ont des
problèmes
de compatibilité
- Différents modèles de gestion de mémoire, de système de
type, de
concurrence, etc.
- Duplication des bibliothèques
- Si le langage est originalement écrit en C, les
bibliothèques
écrites en C ne sont plus disponibles
- La plate-forme est décrétée par le client
- "Doit fonctionner avec Java ou .NET" vs. "Doit fonctionner sous
Unix ou
Windows"
- La JVM a une longue histoire d'utilisation et un niveau de
confiance en industrie
- Et maintenant, son code source est ouvert
- L'interopérabilité avec d'autre code est requise de nos jours
- Pouvoir appeler du C n'est plus suffisant
- Java/JVM *est* le langage et la plate-forme
- D'autres langages pour la JVM ont longtemps existé et ont
maintenant
l'appui de Sun
- Java peut être fastidieux et insuffisamment expressif
- Absence de fonctions de premier ordre, pas d'inférence de
types,
etc.
- La capacité de pouvoir appeler Java est critique
- Clojure est le langage, la JVM est la plate-forme
La programmation orientée-objet est surestimée
----------------------------------------------
- Créée pour la simulation, elle est maintenant utilisée partout, même
lorsque
que c'est inapproprié
- Encouragée par Java et C# dans toutes les situations dû à
l'absence de
support idiomatique pour tout autre paradigme
- Les objets modifiables sont le nouveau code spaghetti
- Il est difficile de raisonner à leur sujet, de les comprendre et
de les
tester
- Ils sont un désastre pour la programmation concurrentielle
- L'héritage n'est *pas* la seule façon de faire du polymorphisme
- "Il est préférable d'avoir 100 fonctions qui opèrent sur une
structure de
données que d'avoir 10 fonctions qui opèrent sur 10 structures de
données" -
Alan J. Perlis
- Les structures de données de Clojure sont des objets immuables,
représentés
par des interfaces. Autrement, Clojure n'offre pas de système de
classes.
- Clojure possède un grand nombre de fonctions pour un petit nombre de
structures de données primaires (seq, map, vecteur, ensemble)
- Écrivez du Java en Java et utilisez le à partir de Clojure
Le polymorphisme est une bonne chose
------------------------------------
- `switch`, la correspondance structurelle, etc. produisent des
systèmes
fragiles
- Le polymorphisme produit des systèmes extensibles et flexibles
- Les multi-méthodes de Clojure découplent le polymorphisme de la
programmation orientée-objet et des types
- Support pour plusieurs taxonomies
- La répartition se fait via des propriétés statiques, dynamiques
ou
externes, via du méta-data, etc.
La concurrence et le future multi-coeur
---------------------------------------
- L'immuabilité élimine beaucoup de problèmes
- Partage entre les threads
- Mais des états changeants sont une réalité pour certains types de
programmes
- Le verrouillage manuel est trop difficile à faire correctement
- Le système de mémoire transactionnelle et le système d'agents de
Clojure
s'occupent du travail difficile
Pour plus d'informations sur Clojure, visitez le site web officiel:
http://clojure.org
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To post to this group, send email to clojure@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
-~----------~----~----~----~------~----~------~--~---
