Une question de langage

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

Cet article vous a plu ? Pourquoi ne pas le partager ?