Chapitre 1 Préliminaires

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

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

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)

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.

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é

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]

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.)

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.

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.

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

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

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++)

Influence de l'architecture 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)

Architecture de von Neumann Processeur Périphérique d'entrée Périphérique de sortie UAL Contrôle Mémoire

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

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.

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

Implémentation Compilation Pure interprétation Implémentation hybride 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.

Les différents niveaux d'un ordinateur Le 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.

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

Étapes de la compilation

Chargement et mise en mémoire mise en mémoire des différentes composantes Édition de liens : processus consistant à connecter ensemble les programmes usagers et les programmes systèmes.

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

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.

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.)

Le processus de l'interprétation

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)

Étapes d'une implémentation hybride

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

Préprocesseurs Sert à Troubles potentiels Le préprocesseur C: 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.

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++

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.