1-1

Chapitre 1

Préliminaires

1-2

Chapitre 1: Sujets

• Raisons pour étudier les langages de programmations

• Domaines d'application• Critères d'évaluation• Influences sur la conception des langages• Catégories de langages• Compromis et conception• Méthodes d'implémentation• Environnement de programmation

1-3

Raisons pour étudier les principes des langages de programmations• Améliorer ses capacités d'expression• Outils pour choisir un langage approprié• Permet d'apprendre plus facilement un

autre langage• Permet de comprendre les motifs

justifiant une implémentation• Développement de l'informatique

– Les langages les plus populaires ne sont pas toujours les meilleurs

1-4

Domaines d'application

• Scientifique– Calcul en point flottant– Fortran (1957)

• Affaires– Production de rapports, nombres décimaux et caractères– COBOL (1960)

• Intelligence artificielle– On manipule des symboles plutôt que des nombres– LISP (1959), Prolog (1973)

• Programmation système– L'efficacité est essentielle car l'utilisation est continue– C (1972)

• Web – Collection éclectique de langages: langages de balisage (e.g.,

XHTML), langages de script (e.g., PHP, JavaScript), usage général (e.g., Java)

1-5

Critères d'évaluation

• Lisibilité: Facilité avec laquelle un programme peut être lu et compris

• Expressivité: Facilité avec laquelle un langage peur être utilisé pour créer un programme.

• Fiabilité: Permet d'écrire des programmes conformes aux spécifications sous toutes conditions.

• Coût: Coût général d'acquisition, d'apprentissage et d'utilisation.

1-6

Critères d'évaluation : Lisibilité

• Simplicité– Petite taille – Faible multiplicité des opérations

Exemple: x=x+1;

x+=1;

x++;

++x– Un minimum de surcharge des opérateurs– Pas d'exagération dans la simplicité

1-7

Critères d'évaluation : Lisibilité

• Orthogonalité– Un petit nombre de primitives et un petit nombre de

règles pour les combiner • Toutes les combinaisons sont possibles et ont un

sens• Le sens ne dépend pas du contexte

– Exemple 1: En C, une fonction peut retourner une structure mais pas un tableau

– Exemple 2: En C, Le sens de x+y dépend du type de x et y

– Orthogonalité vs simplicité (langages fonctionnels)

– Pas d'exagération: • Ex C: T[3] = *(T+3) = *(3+T) = 3[T]

1-8

Critères d'évaluation : Lisibilité

• Sructures de contrôle– Présence de structures de contrôle bien connues (e.g.,

while plutôt que goto)• Types et structures de données

– Présence de mécanismes pour definir des structures de données.

– Exemple: booléen– Exemples: enregistrements

• Syntaxe– Forme et longueur des identificateurs– Mots réservés et méthode pour construire des

instructions composées (Ada: end if et end loop)– syntaxe et sémantique

• Exemple: static en C• Exemple: UNIX (grep, ls, more, etc.)

1-9

Critères d'évaluation: expressivité

• Simplicité et orthogonalité– Un petit nombre de primitives et un petit ensemble

de règles pour les combiner.

• Support à l'abstraction– Possibilité de définir et d'utiliser des structures

complexes de façon à en ignorer les détails– Exemple: macros et sous-programmes– Exemple: construction d'un arbre en Fortran vs C++

• Convivialité– Opérateurs puissants facilitant l'expression des

opérations – Exemple: inclusion du for dans les langages

modernes.

1-10

Critères d'évaluation : Fiabilité

• Vérification des types– vérifier les erreurs de types

• Exceptions– Interception à l'exécution des erreurs et application de

mesures correctives

• Alias– Présence de 2 ou plusieurs noms distincts pour référer à

un même case mémoire.– Exemple: 2 pointeurs vers le même objet.

• Lisibilité et facilité d'écriture– Un langage avec lequel il n'est pas possible d'exprimer

de façon naturelle un algorithme nécéssitera une méthode plus compliquée et moins fiable.

1-11

Critères d'évaluation : Coût

• Formation des programmeurs• Écriture du programme (adapté au

domaine d'application)• Compilateur (rapidité et disponibilité)• Rapidité d'exécution • Fiabilité• Facilité de maintenance

1-12

Critères d'évaluation : Autres

• Portabilité– Facilité avec laquelle un programme peut être

utilisé sur plusieurs plateformes (standardisation)

• Généralité– Utile pour un large éventail d'applications

• Définition– Complétude et précision de la définition

formelle

1-13

Facteurs influençant la conception des langages

• Architecture des ordinateurs– Architecture de von Neumann

• Méthodologies de programmation– De nouvelles méthodologies de

développement de logiciels (e.g., orienté objets) conduisent au développement de nouveaux langages de programmation (e.g Smalltalk, C++)

1-14

• Dominance des languages impératifs à cause du modèle de von Neumann

• Architecture de Von Neumann – Données et programmes sont stockés en mémoire– La mémoire est séparée du CPU– Instructions et données sont transférées de la mémoire

vers le CPU

• Caractéristiques des langages impératifs– Les variables représentent des cases mémoire– Les instructions d'affectation modélisent le transfert de

données.– Efficacité des itérations (vs la récursion)

Influence de l'architecture

1-15

Architecture de von Neumann

Mémoire

Périphériquede sortie

Périphériqued'entrée UAL Contrôle

Processeur

1-16

Influences des méthodologies de programmation

• Années 50 et début 60: La principale considération est la rapidité d'exécution

• Fin 60: Programmation orientée procédure– L'efficacité des programmeurs devient plus

importante – lisibilité, meilleures structures de contrôle– programmation structurée– conception top-down et rafinement progressif

• Fin 70: Programmation orientée données– abstraction des données

• Milieu 80: Programmation orientée objets– Abstraction des données + héritage + polymorphisme

1-17

Catégories de langages

• Impératifs– Principaux aspects: variables, affectations et itérations– Exemples: C, Pascal

• Fonctionels– Fonctions appliquées à des paramètres– Exemples: LISP, Scheme

• Logiques– À base de règles apparaissant dans un ordre

quelconque– Exemple: Prolog

• Orientés objets– Exemples: Smalltalk, Java, C++

• Langages de description de données– Ex. XHTML, Postcript, etc.

1-18

Compromis de conception

• Fiabilité vs. coût de l'exécution– Exemple: Java demande à ce que toutes les références

à l'indice d'un tableau soient vérifiées.

• Lisibilité vs. expressivité– Exemple: APL contient un grand nombre d'opérateurs

permettant à des calculs complexes d'être exprimés de façon extrèmement concise mais au prix d'une moins bonne lisibilité

• Expressivité vs. fiabilité– Exemple: Les pointeurs en C sont puissants et très

flexibles mais sont la cause de programmes peu fiables

1-19

Implémentation

• Compilation– Les programmes sont traduits en langage machine

avant l'exécution.

• Pure interprétation– Les instructions d'un programme sont interprétées par

un autre programme (l'interpréteur)

• Implémentation hybride– Les programmes sont traduit dans un langage

intermédiaire facilement interprétable

• Compilation à la volée (JIT)– la traduction du code intermédiaire au code machine

est effectué en cours d'exécution au moment du premier appel d'une méthode.

1-20

Les différents niveaux d'un ordinateurLe système

d'exploitation et l'implémentation des langages appartiennent à des couches situées au dessus de l'interface machine

Chaque implémentation d'un langage peut être vu comme une machine virtuelle.

1-21

Compilation

• Traduit un programme écrit en langage de haut niveau (code source) en code conpréhensible par la machine (langage machine)

• Traduction lente, exécution rapide• Les différentes phases de la compilation:

– analyse lexicale: converti les caractères du code source en unitées lexicales

– analyse syntaxique: transforme les unitées lexicales en arbre syntaxique (parse tree) représentant la structure du programme

– analyse sémantique: génère le code intermédiaire; cherche certains type d'erreur (e.g. erreurs de types)

– génération du code machine

1-22

Étapes de la compilation

1-23

Chargement et mise en mémoire

• Chargement : – mise en mémoire des différentes composantes

• Édition de liens : – processus consistant à connecter ensemble

les programmes usagers et les programmes systèmes.

1-24

Exécution du code machine

• Cycle chargement-exécution (sur une architecture de von Neumann)

initialiser le compteur ordinal (PC)

répéter à l'infini

charger l'instruction pointée par le PC

incrémenter le PC

décoder l'instruction

exécuter l'instruction

fin répéter

1-25

Le goulot d'étranglement de Von Neumann

• La vitesse de connection entre le CPU et la mémoire limite la vitesse de l'ordinateur

• La vitesse d’exécution des instructions est beaucoup plus grande que la vitesse de connection mémoire-CPU

• Cette perte de performance causé par la vitesse de transfert entre la mémoire et le CPU est connu sous le nom de goulot d'étranglement de von Neumann.

• C'est le principal facteur responsable de la limitation de la vitesse d'un ordinateur.

1-26

Interprétation pure

• Le programme est traduit en cours d'exécution.• Facilité d'implémentation des programmes (les

erreurs à l'exécution peuvent immédiatement être affichées)

• Exécution plus lente (10 à 100 fois)• Requiert plus d'espace mémoire (table des

symboles)• Après une perte de popularité (APL, Snobol, Lisp,

Basic), ce type de langage a effectué un retour récent (e.g., JavaScript, PHP, etc.)

1-27

Le processus de l'interprétation

1-28

Implémentation hybride

• Compromis entre les langages compilés et interprétés

• Langage intermédiaire (bytecode)• Plus rapide qu'une interprétation pure• Exemples

– Les programme Perl sont partiellement compilés afin de détecter les erreurs avant l'interprétation

– Toutes les implémentations initiales de Java étaient hybrides; (Java Virtual Machine)

1-29

Étapes d'une implémentation hybride

1-30

Implémentation juste-à-temps (JIT)

• Langage intermédiaire• Compilation du code intermédiaire en

code machine en cours d'exécution• La version en code machine est conservé

pour les appels subséquents• Les systèmes JIT sont largement utilisés

pour les programme Java• Les langages .NET sont implémentés à

l'aide d'un système JIT

1-31

Préprocesseurs

• Sert à – indiquer l'inclusion d'autres fichiers– utiliser des macros– compilation conditionnelle

• Troubles potentiels– #define exp(A) ((A)*(A))– exp(x++) devient ((x++)*(x++))

• Le préprocesseur C:– #include, #define, #ifdef, #else, etc.

1-32

Environnements de programmation• Collection d'outils utilisés dans le développement

de logiciels• UNIX

– Système d'exploitation et collection d'outils– Maintenant utilisé à partir d'un interface graphique

(e.g., CDE, KDE, or GNOME)

• Borland JBuilder– Environnement graphique pour le développement

d'applications Java

• Microsoft Visual Studio.NET– Environnement visuel complexe– Supporte C#, Visual BASIC.NET, Jscript, J#, et C++

1-33

Sommaire

• L'étude des langages de programmation est utile pour plusieurs raisons:– Améliore nos qualités de programmeur– Nous permet de choisir un langage intelligemment– Permet d'apprendre de nouveaux langages plus

facilement• Principaux critères d'évaluation:

– Lisibilité, facilité d'écriture, fiabilité, coût• Les principaux facteurs ayant influencé la

conceptions des langages sont l'architecture des machines et les méthodologies de développement de logiciels

• Les principales méthodes d'implémentation sont: la compilation, l'interprétation pur et les méthodes hybrides.