Discussion :

[Stéphane le calme]

Ces anciens langages de programmation qui ont la peau dure
et refusent de disparaître

Si de nouveaux langages de programmation ont vu le jour pour répondre à des besoins technologiques spécifiques ou alors dans le but de simplifier la tâche aux développeurs, les anciens ont la peau dure et ne disparaisse pas totalement. Pour preuve, voici une liste de langages qui datent des années 1950 et qui sont toujours utilisés aujourd’hui :

• ALGOL (acronyme d’Algorithmic Oriented Langage) : il a été créé en 1958 par un groupe constitué par des américains et des européens. Sa période de gloire a duré 10 ans, de 1958 à 1968. La plupart du temps utilisé pour le calcul scientifique, ALGOL est la première tentative d’un langage qui pourrait transcender sa plateforme et être utilisé sur différentes machines. A cause du fait que, dans sa forme initiale, il n’avait pas de protocole d’entrée-sortie (un programme écrit en ALGOL ne pouvait par exemple pas demander à un utilisateur de saisir un chiffre, le chiffre devait déjà être intégré dans le code – précisons que ce problème a été corrigé dans Algol 68 qui a été défini en décembre 1958 - ) mais aussi de sa mauvaise adaptation aux programmes de gestion, il a été jaugé plus adapté pour le travail de recherche que pour une utilisation commerciale. Sa présence est minimale même si plusieurs langages (comme le Pascal) gardent des traces de lui dans leurs codes.
  
  Exemple de code Algol :
  
  

  Code :

  Sélectionner tout - Visualiser dans une fenêtre à part

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  procedure Absmax(a) Size:(n, m) Result:(y) Subscripts:(i, k);
   value n, m; array a; integer n, m, i, k; real y;
   comment Le plus grand élément en valeur absolue de la matrice a de taille
   comment n par m est transféré à y et les indices de cet élément à i et k
   begin integer p, q;
    y := 0; i := k := 1;
    for p:=1 step 1 until n do
    for q:=1 step 1 until m do
    if abs(a[p, q]) > y then
    begin
    y := abs(a[p, q]);
    i := p; k := q
    end
   end Absmax

• Le COBOL (acronyme de Common Business-Oriented Language) : officiellement créé le 18 septembre 1959 suite à l’initiative du Short Range Committee, il a connu ses années de gloire entre 1960 et 1980. Comme son nom l’indique, il servait principalement aux systèmes d’entreprises : comptabilité, assurance, etc. Il est toujours étudié à l’école et est également utilisé dans les grandes entreprises, notamment les institutions financières qui disposent (et développent) d’applications dans ce langage, même si son usage pour les nouveaux projets semble désormais limité. Si en 2005, le cabinet d’analyse Gartner estimait à 75% les données du monde des affaires traitées par des programmes en COBOL et que 15% des nouveaux programmes développés dans cette industrie le seraient dans ce langage, l’Index Tiobe place désormais ce langage en 18e place pour un pourcentage de 0,95% des recherches effectuées en juin 2015.
  
  
  
  
  
• Le PL/I ou PL/1 (Programming Language Number 1) : est un langage de programmation développé par IBM dans le début des années 1960 (bien qu’il fut présenté vers la fin). Il a connu ses heures de gloire au début des années 1970. L’un de ses objectifs était de pouvoir remplacer indifféremment les langages à destination scientifique, tel qu’ALGOL, ou des langages comme COBOL, plus adapté aux problèmes de comptabilité et de gestion. Ses capacités de points d'entrée génériques dans les procédures offraient une possibilité qui se retrouvera avec C++. Il avait pour but de devenir le langage privilégié de programmation des ordinateurs universels IBM 360 et 370. Les langages de programmation systèmes XPL, PL-16 (pour le Télémécanique T1600 et le Solar-16) et PL/M sont dérivés de PL/I. Il en va de même pour les langages CUPL et PL/C développés à Cornell.
  
  
• Le PASCAL : créé en 1968 par Niklaus Wirth, il atteint son apogée dans les années 1980. Il s’agit de l’un des descendants les plus utilisés d’ALGOL qui l’a surtout été dans l’enseignement et le développement logiciel pour les ordinateurs Apple. Parmi les implémentations actuelles de Pascal, nous pouvons citer le Turbo Pascal ou le Delphi.
  
  
• Le LISP (acronyme de List Processing) : créé en 1958 par John McCarthy alors qu’il était encore au MIT, il s’agit probablement d’une des plus anciennes familles de langages impératifs et fonctionnels. S’il a d’abord été développé en tant que modèle pratique pour représenter des programmes, il deviendra dans les années 1960 un langage de prédilection dans la recherche en Intelligence Artificielle (en raison notamment de sa flexibilité et de son expressivité), de systèmes de défenses aériennes. Les langages Lisp sont aujourd'hui utilisés dans de nombreux domaines, de la programmation Web à la finance en passant par les travaux en IA.
  
  
• L’APL (acronyme de A Programming Language) : créé en 1962 par Ken Iverson, il a été au sommet de sa popularité dans les années 1960. Il a été très utilisé dans les mathématiques appliquées puisqu’il permet notamment de manipuler aisément des tableaux de 1 à N indices (N variant de 7 à 255 selon l’implémentation considérée) de façon globale. Les opérations puissantes de feuilletage (lamination) ainsi que les opérateurs de réduction, expansion, compression, produit intérieur et produit extérieur évitent souvent toute nécessité d’indices de boucle explicite - ainsi d’ailleurs que l’usage de boucles lui-même. Il n’est pas très répandu de nos jours mais continue d’être utilisé dans certains domaines spécifiques comme l’identification d’ADN.
  
  
• Le Fortran (acronyme de Formula Translator ): créé en 1957 par John Backus d’IBM, ce langage, premier langage de programmation de haut niveau, a connu son essor dans les années 1960 – 1970. Son usage principal est le calcul scientifique. Il est encore très utilisé parmi les physiciens et les ingénieurs.
  
  
• Le LOGO (du grec « logos » qui signifie « raison, discours, parole ») : né à la fin des années 1960 de Marvin Minsky et Seymour Parpert au sein du Computer Science and Artificial Intelligence Laboratory (Laboratoire d'intelligence artificielle et d'informatique) du MIT. L’appellation issue de « Logos » recouvre deux concepts : un mode d’apprentissage inspiré des travaux de Jean Piaget sur le développement cognitif de l’enfant et un type d’environnement informatique, à partir d'un langage adapté du LISP spécialement conçu dans une démarche de pédagogie active inspirée des travaux de celui-ci. Logo est un langage de programmation orientée objet réflexif qui a connu son apogée entre les années 1970 et 1980.
  

Source : Bloomberg

Et vous ?

Avez-vous essayé l'un d'eux ? Pouvez-vous partager votre expérience ?

Avez-vous des éléments à rajouter à la liste ?

[JavaBean]

Beaucoup de ces langages dits «anciens» sont bien plus modernes que certains langages à la mode aujourd'hui...

[curt]

Dans une autre vie, j'utilisai du Pascal UCSD, du Logo et bien évidemment du Basic.
C'était les années 80 où tout démarré à la portée du public.



Curt

[X5-495]

Bonsoir,

Utiliser est un bien grand mot mais au début des années 90, à la Fac des Sciences, j'ai appris le Turbo Pascal pour commencer et ensuite le LISP a tenté de m'être expliqué.

Si le premier me plaisait et me permettait de réaliser des trucs "complexes" pour moi, même si cela restait dans le cadre purement scolaire, j'ai vraiment apprécier ce langage. Le second m'a éloigné de possible études en informatique, je n'ai jamais vraiment compris ce langage, en dehors de sa puissance.

Je n'oublie pas le Basic par lequel j'avais commencé dans les années 80 su mon Hector 2HR.

Comme je l'ai dit dans ma présentation, me prétendre capable de programmer de par ces études, serait me moquer du monde.

Je réussis plus à bricoler qu'autre chose.

Cordialement.

[landry161]

Je n'oublie pas le Basic par lequel j'avais commencé dans les années 80 su mon Hector 2HR.
Cordialement.

J'étais même pas encore né. Alors là

[RyzenOC]

Bien sympa cette news,

Dans le même style, je crois que je vais aussi en faire une, mais sur les langage avec des syntaxe exotique .
Je connais un langage ou on ne peut faire que des fonction récursive.

Ce qui est bien avec certains langages informatique, c'est leurs approche différente des autres langage (grâce a leurs syntaxe notamment) ce qui permet de faire des choses bien différente des autres langages.

Aujourd'hui, la java, le python, le c++, le C#,..etc ils ont la même morphologie si je puis dire, on peut faire les mêmes choses avec ces langages, a quelques petites différences.
Si on prend un langage comme l'erlang ou l'assembleur, c'est radicalement différent.

[Invité]

Si on prend un langage comme l'erlang ou l'assembleur, c'est radicalement différent

[troll]
C'est surtout le fait d'avoir plus de libertés sans avoir des warnings et errors à la pelle dès que l'on essaye d'être un peu créatif dans le design du code et tout ceci sans tout casser
[/troll]

[DelphiManiac]

Allez j'ajoute ma pierre nostalgique à l'édifice :p

Le premier langage que j'ai utilisé, à titre professionnel, se nommait RPL-11 et tournait sur l'os RT-11 qui lui même étais un des OS des PDP-11, famille d'ordinateurs de chez DEC (Digital Equipment Corporation, N° 2 mondial après IBM, à l'époque !!)

Ce langage étais de la famille des langages apparentés à FILETAB. C'étais un langage globalement orienté application de gestion. Une de ces principales particularités étais dans la manière de formuler les tests sous forme de table de décision.

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
*DETAB Decision.table.name
C IF   called.decision.table                     Y N N
  IF   Second.table                              - Y N
A CALL Action1                                   X . .
  CALL Action2                                   . X .
  REPEAT                                         X X .
  EXIT F                                         . . X

Je n'ai jamais retrouvé, depuis, une manière plus élégante d'écrire un ensemble de conditions et les actions qui en découlent.


Pour en revenir au titre du sujet, à savoir s'il a la peau dure, je n'ai aucune idée de la part de marché que représente encore ce langage, mais un dernier éditeur persiste à le maintenir et à le faire tourner sous windows, linux et d'autres OS plus ésotériques.


FILETAB -> https://en.wikipedia.org/wiki/Filetab
RapidGen -> http://rapidgen.com/systems/data-sources/filetab/, le dernier éditeur, à ma connaissance, qui continu de maintenir ce langage.

[pvincent]

Fortran est un ancêtre qui se porte bien: la dernière norme date de 2008, une mise à jour est prévue en 2015 et les compilateurs Fortran font partie des offres de nombreux constructeurs/éditeurs qui touchent au calcul scientifique.

Quand on juge un langage, il ne faut pas négliger l'importance des bibliothèques existantes, comme le rappelle ce post à propos de python
http://lavieestmaloptimisee.blogspot...lhumanite.html
et la longue vie de Fortran qui va de pair avec une bonne compatibilité avec les versions anciennes permet à la fois d'avoir accès à de très nombreuses bibliothèques et d'exécuter facilement de vieux programmes (vieux ne ve pas dire obsolète).

Ceci dit, la syntaxe de Fortran est bien adaptée à ce qu'on souhaite faire en calcul intensif.

[Ndugu]

JAVASCRIPT!!!!!!!!!!!!!

[Carhiboux]

[TROLL]
LISP : Lots of Insipid and Stupid Parenthesis
[/TROLL]

Bon par contre, c'est le jour ou tu fais du lisp que tu te rends compte que tu es super formaté et que le fonctionnel n'est pas dans nos habitudes!

[maske]

Moi j'utilise Smalltalk - et je suis pas un vieux - qui remonte à 1969 (crée en 1969, première version en 1972). Ça n'est pas forcément «vieux» comparé au C par exemple (1972 je crois) mais smalltalk est considéré comme obsolète et dépassé. C'est une réputation qui le suit à tort car non seulement il est toujours maintenu et donc à jour technologiquement mais il permet de faire depuis 30 ans ce qu'aucun «gros langage» (comprendre «à la mode dans l'industrie») ne permet encore de faire à ma connaissance (debug et modification de code à l'exécution, inspection et modification en cours d'exécution du modèle et du méta-modèle, etc.).

Le langage continue d'évoluer par exemple Pharo Smalltalk (http://pharo.org/) est l'exemple le plus parlant de nouvelles technologies qui portent Smalltalk et les projets qui tournent autour.

Ça reste peu utilisé en france - quelques pme dont la mienne (on commercialise un gros erp en full smalltalk), quelques grosses boites, des banques, des assurances... Un peu plus utilisé à l'étranger. La faute à un retard (volontaire car marché de niche... c'est con je sais...) au niveau exécution sur multi-coeurs et modernité des interfaces graphiques (on a du se retaper une bonne partie nous mêmes pour avoir un rendu plus sympa).

Hélas Smalltalk n'est pas forcément un bon choix pour démarrer un projet malgré tous ses avantages (et j'aime pas du tout dire ça...).

[Christophe P.]

Ce mois-ci j'ai modifié une page ASP (pas .NET, ASP tout court) de 4500 lignes.

[Tr0n33]

[TROLL]
LISP : Lots of Insipid and Stupid Parenthesis
[/TROLL]

Bon par contre, c'est le jour ou tu fais du lisp que tu te rends compte que tu es super formaté et que le fonctionnel n'est pas dans nos habitudes!

Oh oh oh, je sens pointer le débat. Syntaxe très simple, notation préfixée, typage dynamique, le code est lui même une structure de données grâce aux s-expressions (en gros le code est lui même une expression). Puissance gigantesque pour la mise en oeuvre de méta-modèle et l'analyse syntaxique. CLOS (Common Lisp Object System) est tout bonnement l'un des premiers langages objets. J'avais adoré ce langage à l'université et je ne l'ai jamais abandonné. Il a précédé SmallTalk d'ailleurs pour les premières normes ANSI sur la POO. Et c'est surtout l'un des premiers MOP.

Aucune parenthèse n'est stupide en réalité et l'importance est comprise quand on regarde la puissance réelle des s-expressions. Sa sémantique est très proche des formalismes du lambda calcul notamment sur les règles de parenthésage dont les gens se foutent ou ne comprennent pas l'utilité (généralement) : association à gauche par convention et parenthésage du terme de tête (ou la notion d'alpha conversion dans la capture). Ces deux règles du lambda calcul se retrouvent directement dans l'expression de la sémantique du langage LISP.

Bon j'avoue, le néophyte ou l'informaticien qui ne souhaite pas user de concepts mathématiques, qui ne travaille pas sur la sémantique ou la méta modélisation, n'a strictement pas besoin de ce langage. Mais je dois avouer, depuis ma tendre jeunesse universitaire, j'ai toujours eu un faible pour la puissance de ce langage et son côté très proche des théories informatiques.

D'ailleurs plus généralement, ces "anciens" langages ont un avantage sur les nouveaux : ils apprennent l'informatique; c'est à dire qu'ils sont proches des théories mathématiques qui ont mené à la construction de nos jolies machines et de leurs modèles programmatiques. C'est fondamental de les connaître pour comprendre ce que l'on manipule. Je n'aime pas voir un développeur qui code sans savoir comment fonctionne son propre langage, d'où il provient, pourquoi. Ce manque de curiosité crée une certaine forme de magie (l'assembleur n'apprend pas tout, notamment les vrais éléments de théorie de la compilation ou de tous les mathématiques sur les théories de la calculabilité qui sont fondamentales : on va de la décidabilité au lambda calcul pour comprendre les logiques d'ordre supérieur) et je trouve cela particulièrement dangereux et soumis à l'idéologie (ou au dogme). Il suffit de donner les avantages et défauts d'un concept pour que ce type de développeur le boive comme de la soupe et le croit. J'aime vérifier les théories mathématiques et la provenance de certains langages, j'aime regarder et vérifier qu'on ne me raconte pas de gros bobards; je déteste l'apparence magique (un peu à l'image des utilisateurs de téléphones portables qui ne savent pas le moins du monde comment fonctionne "réellement" leur truc). Bref, ils sont loin d'être à jeter. Après, je note une confusion entre les langages développés au niveau universitaire et ceux développés spécifiquement par le privé : une logique qu'on retrouve d'ailleurs aujourd'hui.

En tout cas, j'ai bien aimé cette article, il m'a rappelé de vieux souvenirs.

Merci.

[Invité]

l'assembleur n'apprend pas tout

J'aime vérifier les théories mathématiques et la provenance de certains langages, j'aime regarder et vérifier qu'on ne me raconte pas de gros bobards;je déteste l'apparence magique

(Tout programme peut s'écrire qu'avec des mov, add, jcc, jmp, in/out, tu voulais être débarrassés de la magie ? te voilà servi )
(Enfin c'est loin d'être fini si je devais énumérer tout ce qui est de la poudre aux yeux dans vos langages bourrés de macro ultra high level (= + - * / "compiler's keyword" func() "structure de données" "byebye les registres" ...) )

[maske]

(Tout programme peut s'écrire qu'avec des mov, add, jcc, jmp, in/out, tu voulais être débarrassés de la magie ? te voilà servi )
(enfin c'est loin d'être fini si je devais énumérer tout ce qui est de la poudre aux yeux dans vos langages bourrés de macro ultra high level )

Pas compris... (il a pas dit que l'assembleur c'était de la magie...).

C'est quoi les macros ultra high level ?

[Invité]

Relis, j'ai complété mon message, il a dit que seul LISP et ses copains suffisait à être débarrassé de toute la magie que peut offrir un compilateur pour faire du mega high level, sauf l'asm

[maske]

Toujours pas compris.

Non il a dit que les anciens langages, dont LISP, «forcent» une curiosité intellectuelle en obligeant l'utilisateur à aborder les concepts fondamentaux qui forment le (un) langage (par exemple le lambda calcul). Cette connaissance générale - pas si théorique que ça - permet de comprendre ou au moins d'imaginer assez précisément les concepts manipulés via l'utilisation d'autres langages.

Je suis assez d'accord d'ailleurs.

[Invité]

Bon alors c'est juste un malentendu ^^

[Tr0n33]

Relis, j'ai complété mon message, il a dit que seul LISP suffisait à être débarrassé de toute la magie que peut offrir un compilateur pour faire du mega high leve

Où est-ce que j'ai prétendu ça ? J'ai conclu en disant que les "anciens" langages étaient proches des théories mathématiques et que LISP était un très bon outil pour les théories de la calculabilité.

On peut effectivement parler de l'assembleur, mais ce n'est qu'un autre outil de bas niveau, pour les concepts fondamentaux des théories (pas pour celles un tantinet avancées que j'évoquais). Par exemple, je prends une machine qui ne peut faire que deux opérations : ajouter 1 et comparer avec 0. Et je m'amuse à comprendre comment on arrive à créer toutes les autres opérations mathématiques ou même juste un simple "move". Pour les théories plus complexes comme la calculabilité, ou le lambda calcul que je prenais pour exemple, tu ne le feras ni ne l'expliqueras simplement qu'avec des move et des add. L'important n'est pas de savoir utiliser une instruction, l'important est de connaître le pourquoi de son existence, qui répond généralement à un problème précis. La magie ne se situe pas qu'à la base, elle est dans la création de concepts successifs.

(Tout programme peut s'écrire qu'avec des mov, add, jcc, jmp, in/out, tu voulais être débarrassés de la magie ? te voilà servi )
(Enfin c'est loin d'être fini si je devais énumérer tout ce qui est de la poudre aux yeux dans vos langages bourrés de macro ultra high level (= + - * / "compiler's keyword" func() "structure de données" "byebye les registres" ...) )

L'assembleur se place juste à un autre niveau. Il est parfaitement impossible de faire du lambda calcul en assembleur. Les couches successives qui mènent des groupes en algèbre jusqu'à une algèbre (concept bien au dessus) doivent toutes être comprises si tu veux avoir une vision de l'abstraction complète et une vue d'ensemble. Vois la notion de groupe comme le langage assembleur et la notion d'espace vectoriel comme le LISP (puis la notion d'algèbre comme du JAVA). Il faut toutes les connaître. Nul part je n'ai dit que l'un ou l'autre était meilleur, j'ai dit qu'ils étaient utiles dans l'apprentissage mathématique de tous les concepts.

Non il a dit que les anciens langages, dont LISP, «forcent» une curiosité intellectuelle en obligeant l'utilisateur à aborder les concepts fondamentaux qui forment le (un) langage (par exemple le lambda calcul). Cette connaissance générale - pas si théorique que ça - permet de comprendre ou au moins d'imaginer assez précisément les concepts manipulés via l'utilisation d'autres langages.

Exactement. Ces anciens langages, au même titre que l'assembleur, sont fondamentaux dans la compréhension. Mais on ne peut juste se cantonner à l'assembleur. J'englobais d'ailleurs l'assembleur. Apprendre les langages de haut niveau sans avoir vu les anciens, posent souvent des soucis; de gros soucis.