Une question de langage

Publié le 11 février 20072 septembre 2019 par Herve Kabla

Attention, billet technique!

Voici un billet magnifique concernant le prochain grand langage de programmation, découvert au hasard d’un surf sur le blog de Scoble. Amis developpeurs ou passionés d’informatique, lisez le jusqu’au bout, vous en tirerez plein d’enseignements.

Tout d’abord une règle de vie qu’il vous semblera étrange de trouver sur ce blog: « Go ugly early ». Steve Yegge a raison. Dans tout domaine, si on veut aller au fond des choses, alors autant commencer par le plus répugnant. Cela permettra de contempler la beauté de choses qui nous aurons paru banales si nous les avions connues en premier.

Ensuite, une règle de base pour tout bon développeur qui se respecte: écrire son propre langage de programmation. A défaut, écrire son propre compilateur, au pire, écrire son propre interpréteur. Cela permet de comprendre réellement ce qui se passe une fois qu’on a séché l’encre de la dernière ligne de code et qu’on laisse agir le compilateur (ou l’interpréteur). On se rend compte alors que derrière le rideau, il s’en passe des choses. C’est comme dans le domaine de la photographie. Les meilleurs photographes argentiques, par le passé, savaient tous ce qui se passé dans la chambre noire.

Pour le reste, Steve Yegge rappelle quelques uns des « avantages acquis » de jeunes générations de programmeurs. De nos jours, un langage se doit, pour être reconnu, de proposer un certain nombre de caractéristiques:

une syntaxe semblable à celle du C, voire du C++
un typage dynamique (avec des options statiques)
de bonnes performances
des outils de programmation (un IDE)
des outils standards, tels que (je ne traduis pas, trop long)
1. Object-literal syntax for arrays and hashes
2. Array slicing and other intelligent collection operators
3. Perl 5 compatible regular expression literals
4. Destructuring bind (e.g. x, y = returnTwoValues())
5. Function literals and first-class, non-broken closures
6. Standard OOP with classes, instances, interfaces, polymorphism, etc.
7. Visibility quantifiers (public/private/protected)
8. Iterators and generators
9. List comprehensions
10. Namespaces and packages
11. Cross-platform GUI
12. Operator overloading
13. Keyword and rest parameters
14. First-class parser and AST support
15. Static typing and duck typing
16. Type expressions and statically checkable semantics
17. Solid string and collection libraries
18. Strings and streams act like collections
être multi-plateforme

Ce gars là a raison. Et il m’a donné un coup de blues, là, comme ça, à presque minuit. je me suis mis à penser à tous les langages de programmationa que j’ai appris depuis que j’ai touché un ordinateur, à commencer par « l’assembleur » de la TI 57 que m’avais offert Andre Castro en 1979. Puis vinrent les premiers langages de programmation, les vrais:

le Basic du Commodore VIC 20
l’assembleur du même VIC 20
l’assembleur du 8086
le Forth, grace à Julien Galand
Le Lisp, enseigné par Chailloux sur les bancs de l’Ecole Polytechnique (Le Lisp de l’INRIA) puis approfondi en DEA IARFAG
le C, sur ATARI ST, avec l’aide de Frederic Brachfeld
le GFA Basic, toujours sur ATARI ST
Pascal, ou plutôt le Turbo Pascal, maitrisé sur les bancs de Telecom Paris pour mon premier projet 3D
Le Lisp, en plus approfondi, avec un cours magistral sur l’évaluateur Lisp donné par un prof dont j’ai oublié le nom, en DEA aux Mines
Caml, découvert lors du même DEA
Prolog, qui me servit à écrire un outil de pronostics pour le championnat de foot saison 1988-1989
SmallTalk, découvert en stage à l’INRIA aux cotés de Henry Borron, magnifique langage, à l’apprentissage rude, mais qu’on n’oublie jamais une fois qu’on y a touché
TAL (Tandem Application Language), sorte de Pascal, appris lors de mon premier projet chez GFI
Objective C, découvert aux hasards de discussions avec Anne Guillais, ancienne collègue chez GFI, qui développait sur station Next
FORTRAN, maitrisé à l’entrée chez Dassault Systemes (noblesse oblige)
ADA, qui servit de base au développement de CIRCE, développé par Cedric Hutt et Patrick Caressa, générateur de systemes experts et ancêtre du knowledge de la V5
C++, découvert chez Dassault Systemes, grace aux cours extraordinaires de Gael Renault
Ksh, découvert à l’INRIA, mais réellement mis à profit en 1995 en développant le premier moteur de recherche sur l’intranet de Dassault Systemes, ainsi qu’un navigateur sur le source Fortran
HTML – mais est-ce un langage de programmation – si proche de DTML, dont j’ai écrit un compilateur en Fortran en 1990
Java, premier langage auquel je me sois formé par la lecture avant tout
PERL et JavaScript, qui m’ont abondamment servi à développer les premières moutures du site Golfworld. JavaScript, avec du recul, me semble le langage le plus étonnant et le plus souple. Sa richesse est sans limites.
PHP, qui sert d’ossature aux pages les plus récentes de Golfworld
C#, le plus beau à mon avis, qui présente les forces de Java sans en exhiber les faiblesses, mais qui a le défaut de ne pas être vraiment multi-plateforme
MAJ du 27 avril 2017: Python, qui est vraiment très sympa au final

En quelques vingt année, je crois avoir été exhaustif. En fait, les seuls langages qui m’ont échappé sont:

Cobol, mais je crois que j’ai eu de la chance
~~Python, sur lequel j’hésite à me lancer~~
VB: je dois avouer ne jamais avoir éprouvé de plaisir de programmation avec les différentes moutures de Basic
Ruby on rails