Reprise du message précédent :
ta fumer koi?

TheJackal a écrit a écrit : ta fumer koi?

  J'ai fumé mon céléron avec un coup d'overclock de trop

Dans le genre exotique, un peu pourri: le Forth.
Inventé à l'époque où la mémoire se contait en octet, très utilisé pour piloter les téléscopes.
Aujourd'hui, complètement aux oubliettes je pense.
 
Que le forth soit avec vous.

le celeron yavait marker jamaiqua ou cuba ?  
parce que ton pate de carton...

Heu korean je pense. Dans la région c'est bien vert aussi mais il faut éviter de consommer sur place.

 
il est encore un peu utilisé, mais très rarement, par des maniaques des calculettes HP qui vénèrent la NPI

le LEX et YACC, qqn connait cette grosse daube?
enfin ca permet de générer du code C assez vite, mais je trouve que c'est vraiment la merde à manipuler, je préfère encore écrire mon code C à la main...

Pti exemple de LEX & YACC
Partie lecicale:
 
%{
 
 
/* Partie lexical */
 
#include "y.tab.h"
 
#define DEBUT 0
#define APRESVAR 1
 
int mode = DEBUT;
 
%}
 
/* Definit un ou plusieurs espaces ou tabulations. */
blancs     [ \t]+
 
/* Definit un chiffre. */
chiffre    [0-9]
 
/* Definit un entier c'est a dire une suite d'un ou plusieurs chiffres. */
entier     {chiffre}+
 
/* Definit la partie exposant d'un reel. */
exposant   [eE][+-]?{entier}
 
/* Definit les nombres a virgule et/ou avec exposant */
virgule    ({entier}[.]{entier}){exposant}?|{entier}{exposant}
 
%%
 
{blancs} { /* On ignore. */ }
 
{virgule} {
             yylval.coef=atof(yytext);
             return COEF;
          }
 
{entier}  {
           if (mode == APRESVAR)
           {
             yylval.expo=atof(yytext);
             mode = DEBUT;
             return EXPO;
           }
           else
           {
             yylval.coef=atof(yytext);
             return COEF;
           }
          }
 
[+]       {
           mode = DEBUT;
           return PLUS;
          }
[-]       {
           mode = DEBUT;
           return MOINS;
          }

•       return FOIS;

[X]       {
           mode = APRESVAR;
           return VARIABLE;
          }
 
[(]       return PRTHESEG;
[)]       return PRTHESED;
 
\n        return FIN;
.         return ERREUR;
 
%%
 
Partie Syntaxique
%{
 
 
/* Analyseur syntaxique. */
 
#include "variable.h"
 
%}
 
%union{
       double coef;
       int expo;
      }
 
/* Pour la valeur du coefficient d'un monome. */
%token <coef> COEF
/* Pour la valeur de l'exposant d'un monome. */
%token <expo> EXPO
 
/* Les nombres. */
%token COEF EXPO
/* Les arrets. */
%token FIN ERREUR
/* La variable. */
%token VARIABLE
/* Les signes. */
%token PLUS MOINS FOIS
/* Les parentheses. */
%token PRTHESEG PRTHESED
 
%%
 
Ligne:
        FIN          {
                      yyerror("Peut faire mieux." );
                      exit(PB);
                     }
      | Polynome FIN {
                      printf("\nVotre polynome :\n" );
                      Simplifier(p);
                      AfficherPolynome(p);
                      exit(NOPB);
                     }
      | ERREUR       {
                      yyerror("Peut faire mieux." );
                      exit(PB);
                     }
      | Polynome ERREUR  {
                          yyerror("Peut faire mieux." );
                          exit(PB);
                         }
      | Expression FIN {
                        printf("\nVotre polynome :\n" );
                        AfficherPolynome(p);
                        exit(NOPB);
                       }
      | Multiplication FIN {
                        printf("\nVotre polynome :\n" );
                        AfficherPolynome(p);
                        exit(NOPB);
                       }
      | ERREUR FIN       {
                          yyerror("Peut faire mieux." );
                          exit(PB);
                         }
      ;
 
/* Un monome est la base d'un polynome. */
Monome:
      COEF                 {AjouterMonome($1, 0);}
      | COEF VARIABLE EXPO {AjouterMonome($1, $3);}
      | VARIABLE EXPO      {AjouterMonome(1.0, $2);}
      | COEF VARIABLE      {AjouterMonome($1, 1);}
      | VARIABLE           {AjouterMonome(1.0, 1);}
      ;
 
/* Un polynome est une suite de monome. */
Polynome:
      Monome
      | PLUS Monome
      | MOINS Monome          {
                         /* On change le signe du coefficient. */
                                if (alterne) ModifierSigne(p);
                                   else ModifierSigne(ptemp);
                              }
      | Polynome PLUS Monome
      | Polynome MOINS Monome {
                         /* On change le signe du coefficient. */
                                if (alterne) ModifierSigne(p);
                                   else ModifierSigne(ptemp);
                              }
      ;
 
/* Une expression est un polynome parenthesee. */
Expression:
      PRTHESEG Polynome PRTHESED {
                                  if (alterne)
                                  {
                                    Simplifier(p);
                                    alterne = 0;
                                  }
      else Simplifier(ptemp);
                                 }
 
/* Ici, est decrit la multiplication d'une ou plusieurs expressions. */
Multiplication:
      Expression FOIS Expression {
                                  Simplifier(ptemp);
      Multiplier();
      Simplifier(p);
      ptemp = NULL;
                                 }
      | Multiplication FOIS Expression {
                                        Simplifier(ptemp);
            Multiplier();
            Simplifier(p);
            ptemp = NULL;
                                       }
      ;
 
%%
 
/* Ajoute un monome a la liste chainee de monome. */
void AjouterMonome(double coef, int expo)
{
   polynome element;
   /* Reserve la place memoire. */
   element = (struct monome*) malloc ( sizeof(struct monome) );
   /* On regarde a quel polynome on ajoute le monome. */
   if (alterne) element->suivant = p;
      else element->suivant = ptemp;
   /* On affecte les donnees au monome. */
   element->coef=coef;
   element->expo=expo;
   if (alterne) p = element;
      else ptemp = element;
}
 
/* Modifie le signe du coefficient. */
void ModifierSigne(polynome p)
{
  p->coef = -p->coef;
}
 
/* Affiche le polynome. */
void AfficherPolynome(polynome p)
{
  /* Pour faire un peu de place a l'affichage. */
  if (p) printf("\n" );
  /* Tant qu'on n'est pas arrive au bout des monomes. */
  while (p)
  {
    /* Si le coef est nul, on affiche rien. */
    if (p->coef)
    /* Si l'exposant est nul, on affiche que le coef. */
    if (!p->expo) printf("%g", p->coef);
       else
    {
     /* Pour faire -X au lieu de -1X. */
     if (p->coef = -1) printf("-" );
     /* On cherche a faire X au lieu de 1X. */
     if (p->coef != 1 && p->coef != -1) printf("%g", p->coef);
     printf("X" );
     /* On evite X1, on preferera X. */
     if (p->expo != 1) printf("%d", p->expo);
    }
    /* On passe au monome suivant. */
    p = p->suivant;
    if (p) if (p->coef>0) printf("+" );
  }
  printf("\n" );
}
 
/* Simplifie le polynome. */
void Simplifier (polynome p)
{
  double coef;
  int expo;
  polynome courant=p, element=p, precedent, temp;
 
  /* On balaye tout le polynome
  for(; courant; courant=courant->suivant)
  {
    precedent = courant;
    element = courant->suivant;
    while (element)
    {
    /* Si le monome suivant est plus grand que le monome courant
       alors on les echange. */
     if (element->expo > courant->expo)
     {
       coef = element->coef;
       expo = element->expo;
       element->coef = courant->coef;
       element->expo = courant->expo;
       courant->coef = coef;
       courant->expo = expo;
       precedent = element;
       element = element->suivant;
     }
     else
     {
      if (element->expo == courant->expo)
      {
       courant->coef += element->coef;
       precedent->suivant = element->suivant;
       free(element);
       element = precedent->suivant;
      }
      else
      {
       precedent = element;
       element = element->suivant;
      }
     }
    }
  }
}
 
/* Multiplie deux polynomes */
void Multiplier ()
{
  polynome p2temp=p, p3temp=ptemp;
  polynome element, resultat=NULL;
 
  while (p2temp)
  {
    while (p3temp)
    {
      /* On cree un monome resultant de la creation par la
  multiplication d'un monome du premier polynome
  avec un monome du second polynome. */
      element = (struct monome*) malloc ( sizeof(struct monome) );
      element->coef = p2temp->coef * p3temp->coef;
      element->expo = p2temp->expo + p3temp->expo;
      /* On rajoute le monome au polynome resultat. */
      element->suivant = resultat;
      resultat = element;
      /* On passe au monome suivant. */
      p3temp = p3temp->suivant;
    }
    /* On passe au monome suivant. */
    p2temp = p2temp->suivant;
    p3temp = ptemp;
  }
  /* On simplifie le resultat. */
  Simplifier(resultat);
  /* Le resultat est place dans p. */
  p=resultat;
}
 
/* Programme principal. */
main()
{
  /* Initialisation des polynomes. */
  p       = NULL;
  ptemp   = NULL;
  /* On commence a remplir le polynome p. */
  alterne = 1;
 
  fflush(NULL);
  while (!feof(stdin))
    {
      yyparse();
      fflush(NULL);
    }
}
 
yyerror (s)
char *s;
{
  /* Affiche un message d'erreur. */
  fprintf(stderr, "\n%s Ca ne marche pas.\n\n", s);
  exit(ERREUR);
}

et le Java, vous en pensez quoi ??  

 
<troll>
Visual Basic? J'ose appeller ça un langage de programmation mais je pense que c'était, dans vos esprits, totalement exclu (c'est pourquoi personne ne l'ai cité ).
 
</troll>
 
Sinon, vous citez plein de langages qui ne sont pas pourri du tout mais soit ils sont vieux et archaïque (comme l'a déjà dit quelqu'un), soit ils ne vous sont d'aucune utilité (bien qu'ils en ai une), soit ce sont des langages que vous avez appris à l'école et dont on vous a dégouté!

[edtdd]--Message édité par FatherTom--[/edtdd]

Comme language hard, voici un champion potentiel.
 
Qui peut me dire ce que fait le code ci-dessous et quel est le language ?
 
: xxx begin dup . 1- dup 0= until drop ;
100 xxx

[edtdd]--Message édité par tfj57--[/edtdd]

 
le fortran 77 sur station tps reel a l'a**********e....
vraiment pourrave

k'est ki a comme conneries dans ce topic spa possible ...

 
LEX et YACC r0x0r, j'ai jamais trouvé mieux pour ecrire un parseur a vitesse grand V (parceque se taper le code d'un parser a la main, bonjour, je viens de le faire dans un langage qui ne supporte pas le while (non, je vous dirait pas ce que c'est))
 
C'est vrai que c'est choquant le premier coup, mais ils sont finalement super bien adaptés a ce a quoi ils servent.

j'ai lu avec interet la liste des vos languages les plus pourris
mais je pense en avoir trouvé l'un des plus incroyable
Le Brainfuck !
ne riez pas, ca exite bel et bien
des gens programment ils encore avec ca? (faudrait etre fou)
seulement 8 instructions au menu:
>  Increment the pointer.  
<  Decrement the pointer.  
+  Increment the byte at the pointer.  
-  Decrement the byte at the pointer.  
.  Output the byte at the pointer.  
,  Input a byte and store it in the byte at the pointer.  
[  Jump to the matching ] if the byte at the pointer is zero.  
]  Jump to the matching [.  
 
et un compilateur qui fait 240 octets !!
allez un petit exemple de code source a compiler joyeusement:
--quine.b---------------------------------------------------------
>++++++++>++++++>+>+++>++++++>++>+++++>++++>++++++>+>+++>++++>++
+++>+>++++++>+++>+++>+++++>+++++++>+++>++++++>++++>++>++>++++++>
++++>+++>+++>+>++>++>+++++>+++++>++>++++>++++++>+>++>++++>+++++>
++>++++++>++++>+++>+>++++++>++++>+++>+>+++++>++++>+++>+>++++++++
>++>++++>++++++>+>++>++++>+++++>+>+++++>+++>+>++>++++>+++++>+>++
+>++++++>+>+++>++++++>++>+++++>++++>++++++>+>+++>++++>+++++>+>++
++++>+++>+++>+++++>+++++++>+++>+++>++++++>++>++>+++++>++>++++++>
++++>+++>+++++++>++>+++++>+++>+++>+++>+++++++>++>++>++>++>++++>+
+++++>+>++>++++>+++++>++>++++++>++++>++++++++>+++>+>++++++>++++>
+++>+>+++++>++++>+++>+>++>++++>++++++>+>++>++++>+++++>+>+++++>++
+>+>++>++++>+++++>+>+++>++++++>++>+++++>++++>++++++>+>+++>++++>+
++++>+>++++++>+++>+++>+++++>+>+>+>+>+>+>+>+>+>+>++>++>+>++>++>+>
+>+>++>++>+>++>++>++>++++++++>++>++>++>+>+>++>++>++++>++++>++>++
>++++>+++>++++++>++++>++>++++++>+++>+++>+++++>+>+>+>++>++>+>+>+>
+>+>+>++>++>+>+>+>+>+>+>++>++>+>+>+>++>++>+>+>+>+>++>++>+>+>+>+>
++>++>+>+>+>++>+++++>++>++++++++>++++++>++++>+++>+>+>+>++>+++++>
+>+>+>+>+>++>++>++>++++++>++>+++++>++++>++>++>++++++>+++>+++>+++
+++>++++>++>++++++>+++>+++++>+>+++>++++++>++>+++++>+++++>++++>++
>++++++>+++>+++++>+>++++++>++>+++++>++>++++++>++++>+++>+++>+>++>
+>++>+++++>+++++>+++>+++>+++>++++>++>++>++
#>>>-<<<[[>+>+<<-]>[>]+[<]>-[[>]<+[<]>-]<<]>>-[>]#>>>+++++[>+++<-]
>[>+++>>++++>>++++>>+++>>++++++>>++++++>>+++[<<]>-]<->>-->>++>>>
>>>+>>+++>>+>>++++++++++[<<]+[-<+]-[>]<+#[->+<[+[->+]->+<-[+<-]+<
-]>[->+]->>>>.<<<[>.<-]>[>>]<<.[<<]+[-<+]-[>]<+]<+#[->+<[+[->+]->
+<-[+<-]+<-]>[->+]->[[>>+<<-]>>-]<.[<<]+[-<+]-[>]<+]
------------------------------------------------------------------
 
je vois que beaucoup d'entres vous meurent d'impatience de s'y mettre
c'est par la : http://www.muppetlabs.com/~breadbox/bf/
BON COURAGE !

tatata, le forth survit aujourd'hui dans des millions de machines ! pour faire 2+3 en forth, on fait un truc du style  
push 2 // stack = 2
push 3 // stack = 3, 2
add // stack = 5
 
ce qui est exactement le fonctionnement interne de la machine virtuelle java. moi j'adore ! d'autres langages de script fonctionnent peut-être de la même manière, je n'ai jamais regardé ...

Mouais, pas  un seul qui ai cité "Servant IV" !!!
Pourtant, c'est bien aussi, dans le genre archaïque !!
Langage positionnel (un peu comme le GAP) mais en Français...
 
Encore utilisé dans des administrations, des banques, des centres EDF etc etc...
 
Autrefois très prisé par les gendarmeries, les administrations (caf).
 
Et du coup moi je m'en tape encore, de cette daube

Stranger is the winner whith 'Le Brainfuck'
 
Pour ceux qui pensent que le forth n'est plus utilisé, je peux vous dire que c'est pas le cas.
Je suis moi même inscrit à une mailling list sur le forth et ca bouge.
PS : A ma conaissance, le forth est encore utilisé pour programmer, en autre, les satélites de la NASA.

Et l'Ada personne ne le déteste???
Sinon entre Pascal et C/C++, je dois dire que chacun a ses inconvénients et avantages...

moi l'Ada on me l'a enseigne comme 1° langage
et alors je l'ai desteste
mais avec le recul (lol quand meme, je suis pas vieux) je l'aime de plus en plus
 
Le Brainfuck : mais c'est enOOOOOOrme ce truc !!! j'ai hallucine en lisant ton source !!! Y'en a qui on quand meme l'esprit vraiment tordu
moi je dis pour le mec qui a reussi ce pari
moi on m'aurait dit "fait un langage avec le compilateur le + petit possible" j'aurais ete tres loin de ca
 
le Forth : les mecs de ACBM (pirat'mag, les puces informatiques, virus ...) en sont de fervants defenseurs

 
Non, ADA c super!    
Qd ton programme compile, il fait exactement ce que tu veux!    
 
c pas le cas pour le C par exemple....

SCHEME
quand on débarque en première année de DEUG on voit pas tout de suite ni après (si on cherche pas) l'intéret de ce merveilleux langage fonctionnel interprété
c vrai que c lourd!
pour faire une addition on pourrait s'attendre à taper 2+3
benh non c (+ 2 3)
elle est pas belle la vie
heureusement que j'ai découvert son intéret pour faire des scripts mais quand meme, le concepteur aurait pu s'abstenir

Puisqu'on fait l'inventaire des langages...
j'ai eu un cours d'APL (A Programming Language), c'était pas triste... c'est un langage destiné - en gros - à faire des maths. Pour l'utiliser, il faut un clavier spécial, avec une bonne cinquantaine de symboles spéciaux qui représentent les mot-clefs du langage, notamment la +part des lettres greques...
yavait un mot clef pour avoir la dérivée d'une fonction, par ex...
c'était un cours très utile : on a appris les rudiments de ce langage, mais uniquement sur papier

pour faire une addition on pourrait s'attendre à taper 2+3
benh non c (+ 2 3)
 
bah quoi, c'est un langage fonctionnel, c'est genial pour certains calculs ce truc. Effectivement, le premier coups ca choque. Mais quand tu te retrouve a gérer des contraintes, ca r0x0r.
 
Et puis la meme chose en cobol, c'est (globalement, je pratique plus)
add 2 to c
add 3 to c

instantdharma a écrit a écrit : Puisqu'on fait l'inventaire des langages... j'ai eu un cours d'APL (A Programming Language), c'était pas triste... c'est un langage destiné - en gros - à faire des maths. Pour l'utiliser, il faut un clavier spécial, avec une bonne cinquantaine de symboles spéciaux qui représentent les mot-clefs du langage, notamment la +part des lettres greques... yavait un mot clef pour avoir la dérivée d'une fonction, par ex... c'était un cours très utile : on a appris les rudiments de ce langage, mais uniquement sur papier

 
 
ouep! apres le A, y a eu le B, puis le C!
Ils se sont arreté là en faisant un peu evoluer (c++, c#) à quand le D?

à quand le D?
 
Ca vient :  
 
http://linuxfr.org/2001/08/16/4579,0,-1,0,1.php3

 
  Merci! j'etais sûr que ça devait exister!    
 
Sinon, ils veulent faire un java compilé quoi?

Le COBOL pourri ?
Bah ! N'importe n'a ouak !
Dans les domaines financiers et gestion, y'a pas mieux !
Pour tout ce qui est accès à des fichiers séquentiels, indexés et relatif, y'a pas mieux !
Pour tout ce qui est édition formattées, y'a pas mieux !
Pour tout ce qui est traitement en masse (traitements par lot) y'a pas mieux !
 
Son seul gros défaut, c'est qu'il est verbeux, très verbeux ! Et donc les progs sont longs à écrire. Mais cela a été une volonté lors de sa conception. Ses règles d'écritures sont également contraignantes (nom de paragraphe en colonne 8, instructions à partir de la colonne 12, lignes limitées à 72 caractères....), mais à l'époque de sa conception on travaillait avec des cartes perforées, limitées à 80 caractères.  
 
En quinze ans d'expériences, et en ayant utilisé différents langages (Cobol, basic, pascal/delphi, C/C++, Java pour les plus connus), je suis obligé de constater que le cobol reste irremplacable dans le domaine de la gestion ! Bah oui !
 
Il faut pas oublier qu'il existe actuellement plus de 400 langages différents, et qu'ils ont été chacun inventés pour un contexte particulier, et pour répondre à des attentes bien précises des programmeurs.
 
Bref, si pour un nuveau projet les langages existants étaient un peu lourd, ben certains s'amusaient à écrire un nouveau langage spécifique pour le projet...
 
C'est le cas entre autre de C, puisque ses auteurs l'ont créér pour pouvoir écrire un jeu, mais aussi pour écrire l'O.S. qui devait supporter leur jeux (UNIX)

therier>il existe un lien entre le langage A et APL ?

Sans hesiter le COBOL.....

 
Je pense (j'en suis pas sûr, j'en ai jamais vu! trop jeune...) que derriere APL se cache le A et que le PL c pour le fun! (comme C programming language par exemple )

D ? Ca ressemble à de l'Ada, avec un zeste d'Eiffel, un chouia de Java et une syntaxe à la C...
Franchement, je n'en vois pas trop l'intérêt.    
 
Buitoni> Merci pour le flame, mais pour ton information, Ada n'est pas vraiment de la même génération que Fortran ou Cobol. Il est même plus récent que C++. D'ailleurs, C++ s'est inspiré d'Ada pour ses évolutions récentes, comme les templates ou encore les exceptions (excuse du peu). Preuve qu'Ada est un "vieux brol", effectivement...

BifaceMcLeOD a écrit a écrit : D ? Ca ressemble à de l'Ada, avec un zeste d'Eiffel, un chouia de Java et une syntaxe à la C... Franchement, je n'en vois pas trop l'intérêt.       Buitoni> Merci pour le flame, mais pour ton information, Ada n'est pas vraiment de la même génération que Fortran ou Cobol. Il est même plus récent que C++. D'ailleurs, C++ s'est inspiré d'Ada pour ses évolutions récentes, comme les templates ou encore les exceptions (excuse du peu). Preuve qu'Ada est un "vieux brol", effectivement...

 
oui, mais ADA a un typage 'strict'. ADA est anterieur à C++ d'ailleurs...
 
 
According to Sammet, over 200 programming languages were developed between
1952 and 1972, but she considered only about 13 of them to be significant.
 
1957    FORTRAN
1958    ALGOL
1960    LISP
1960    COBOL
1962    APL
1962    SIMULA
1964    BASIC
1964    PL/I
1966    ISWIM
1970    Prolog
1972    C
1975    Pascal
1975    Scheme
1977    OPS5
1978    CSP
1978    FP
1980    dBASE II
1983    Smalltalk-80
1983    Ada
1983    Parlog
1984    Standard ML
1986    C++
1986    CLP(R)
1986    Eiffel
1988    CLOS
1988    Mathematica
1988    Oberon
1990    Haskell

Le c** (c star star)

Salut,
Perso je trouve que le cobol est un des langages les plus simples, et surtout le plus efficace dans le domaine de la gestion !
Et en + j'ai déjà fait des CGI en Cobol (et oui !) et c super simple pour l'interfacer avec un système des gestion écrit en Cobol.
Et enfin je vois mal un système de gestion qui serait programmé en C ou autre Java ...
Bye

 
Ca peut etre vrai lorsque, selon moi,
 
1) Tu as un environement composé de legacy systems
2) Tes requierments sont super précis et ne changent pas
3) Tu ne sais pas utiliser les nouvelles techos et surtout la façon dont elle gère les connection avec les legacy systems
 
Entendu parler d'un J2EE connecteur. Il y a un truc dans le meme gout en .NET
 
Donc je suis pas d'accord avec toi en clair
 
mais bon je respecte ton avis bien sûr

Heureusement, on peut maintenant écrire des CGI en Fortran 77. Joie !

personne n'a cite l'intercal?
deja rien que le guide du programmeur est a mourir.
 
A+
LEGREG

Allez pour le plaisir :
 
http://www.muppetlabs.com/~breadbo [...] /home.html
 
A+
LEGREG

DO (5) NEXT
    (5) DO FORGET #1
        PLEASE WRITE IN :1
        DO .1 <- '?":1~'#32768$#0'"$#1'~#3
        DO (1) NEXT
        DO :1 <- "'?":1~'#65535$#0'"$#65535'
                ~'#0$#65535'"$"'?":1~'#0$#65535'"
                $#65535'~'#0$#65535'"
...
2.2 Uses for INTERCAL
INTERCAL's main advantage over other programming languages is its strict simplicity.
 
l'auteur a surement raison