Programming language.

Besoin

Fournir des instructions à la machine.

Analyse

Le langage de programmation est un formalisme (généralement textuel) :

  • compréhensible par l'homme (qui écrit le code source)
  • traduisible par un logiciel (compilateur, interpréteur) en une suite instructions compréhensibles par la machine (langage machine) : le code objet.

On peut distinguer les langages par :

  • leur mode d'exécution :
    • interprétés : les instructions du code sources sont examinées à l'exécution puis traduite en langage machine.
    • compilés : la traduction de l'interprétation est effectuée à l'avance, de sorte de le programme exécuté est dès le départ un ensemble d'instructions pour la machine.
    • virtuels : à la fois compilés pour et interprétés par une machine virtuelle (Virtual Machine ou VM), c'est-à-dire une machine simulée par un logiciel réécrit pour différentes machines. L'objectif de cette virtualité est la portabilité et ce qu'elle implique (indépendance des contraintes d'un OS, d'une machine, optimisations dynamiques).
  • leur paradigme :
    • procédural, qui se focalise sur le verbe : ouvre (porte). On se préoccupe alors plus des événements qui peuvent survenir dans une application, et de comment ils doivent survenir.
    • OO, qui se focalise sur l'objet : porte.ouvre(). On se préoccupe alors plus des entités existantes et de leurs relations/interactions.
    • hiérarchique
  • leur domaine d'application :
    • programmation
    • requêtes
    • représentation
  • leur niveau d'abstraction :
    • élévé : langages fonctionnels
    • moyen : langages OO
    • faible
    • nul
  • leur génération :
    • 1ère : langage machine (suite de bits)
    • 2ème: assembleur (mnémoniques, manipulation de registres)
    • 3ème: procédural
    • 4ème: automatisation
    • 5ème: interprétation du sens (langue naturelle, IA)

Conception

Un langage est constitué de :

  • mots-clés ou mots réservés, utiliser pour représenter des :
    • déclarations
    • affectations
    • structures de contrôles
      • tests (if)
      • boucles (for, while)
      • branchements (goto, appel de méthode)

Exemples

  • Langages de programmation OO
    Nom Java JavaScript Groovy Objective-C Ruby PHP Perl Python C++ C# Pascal Eiffel Ada SmallTalk Commentaire
    Version/ Fournisseur 1 1 ANSI Borland GNU
    Domaine Technologie Produit/ Release 4 5 0 2 5 Delphi 95
    Exécution JVM Interpréteur Interpréteur Machine CLR Machine Machine Interpréteur
    Compilation Préprocesseur Non Non Oui Oui
    Structures de données Constantes final SomeConstant const constant
    Enumérations Non enum MonEnum { a, b, c } enum MonEnum { a, b, c} Oui type MonEnum is (A, B, C);
    Numériques Entiers byte short int long Byte Short Integer Long [unsigned] char, [unsigned] [long] int byte short int long Byte Short Integer Long INTEGER var: Integer var: Short_Integer
    Flottants float Float float, [long] double float Float REAL DOUBLE Float Long_Float
    Caractères Unique char Character char (8 bits) char Character
    Chaîne String char* String CHARACTER String var
    Booléen boolean Boolean boolean Boolean Boolean
    Enregistrements Classes struct record Classes record
    Type génériques Templates Non Classe<Type> Non Oui var : Classe[ Type] generic type MonType Modèles ou "patrons" de classes
    OO Héritage simple Classe1 extends Classe2 Class1 Oui Classe1: Classe2 Non Oui Classe1 inherit Classe2 Oui Oui
    Héritage multiple Classe1 implements Interface1, Interface2 Oui Classe1: Interface1, Interface2 Non Classe1 inherit Classe2 Classe3 Non Oui
    Structures de contrôle Condition if (cond)
    ...
    else
    ...
    if (cond) ...
    else
    ...
    if cond
       ...
    else
       ...
    end
    if (cond) ... if (cond) ... if cond then ... if (cond) then
    Cas switch (var) {
      case val1: break;   case val2: break;
    }
    switch (var) { x: break; } switch (var) { case x: break; }

    switch (var) { case val1: break; case val2: break; }

    case var is
    when
    val1 => ...
    when val2 => ...
    end case;
    Boucle Itération for (init; while; inc) ... for (init; while; inc) ... someList.each do |someElement|
    ...
    end
    for (init; while; inc) ... foreach (var in col) ... for var in [reverse] discreteRange loop
    ...
    end loop;
    Un au moins do ... while do ... while do ... while
    Tant que while (cond) ... while (cond) ... while (cond) ...
    Suite continue continue continue
    Stop break break break
    Gestion des erreurs Exceptions Oui Non Oui Oui Non Oui Oui
    Robustesse Contrôle des conversions Oui Non Non
    Contrôle des limites de tableau Oui Non
    Contrôle division par zéro Oui
    Gestion mémoire Pointeurs Non Oui Oui Oui
    Allocation Automatique Oui Non Non Non Non
    Libération GC Oui Non Non Non Non Oui Oui Garantie de robustesse
    Mise au point Assertions Non Oui assert.h
  • L2G
    Nom BASIC COBOL PERL Commentaire
    Version/ Fournisseur Microsoft
    Domaine Technologie Produit/ Release Visual Basic
    Exécution Interpréteur Oui Oui
    VM Non Non
    Machine Non
    Compilation Préprocesseur
    Structures de données Constantes Non
    Enumérations Non
    Numériques Entiers var% 32 bits
    Flottants var! var# 32 bits
    Caractères Unique Non 32 bits
    Chaîne var$ Suite de 32 bits
    Enregistrements Non
    Type génériques Templates Non Modèles ou "patrons" de classes
    Structures de contrôle Condition if cond then ... if (cond) { }
    Cas
    Boucle Itération FOR var=exp TO exp [STEP exp] foreach $var (liste) ...
    Un au moins
    Tant que
    Suite NEXT var
    Stop
    Gestion des erreurs Exceptions
    Robustesse Contrôle des conversions
    Contrôle des limites de tableau
    Contrôle division par zéro
    Gestion mémoire Pointeurs
    Allocation Automatique
    Libération GC Garantie de robustesse
    Mise au point Assertions
  • Langages de requêtes
    Nom SQL OQL EJBQL JDOQL Commentaire
    Version/ Fournisseur
    Domaine Technologie Release
  • Langages de représentation
    Nom SGML