La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

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.

Présentations similaires


Présentation au sujet: "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."— Transcription de la présentation:

1 1-1 Chapitre 1 Préliminaires

2 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

3 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

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

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

6 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é

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

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

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

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

11 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

12 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

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

14 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

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

16 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

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

18 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

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

20 1-20 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.

21 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

22 1-22 Étapes de la compilation

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

24 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

25 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 dexé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.

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

27 1-27 Le processus de l'interprétation

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

29 1-29 Étapes d'une implémentation hybride

30 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

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

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

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


Télécharger ppt "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."

Présentations similaires


Annonces Google