Language translators and IDEs · Traducteurs de langages et IDE
| English | Français |
|---|---|
| compiler/kəmˈpaɪlə/ | compilateur |
| source code/sɔːs kəʊd/ | code source |
| translator/trænˈsleɪtə/ | traducteur |
| machine code/məˈʃiːn kəʊd/ | code machine |
| assembler/əˈsemblə/ | assembleur |
| assembly language/əˈsemblɪ ˈlæŋɡwɪdʒ/ | langage assembleur |
| object code/ˈɒbdʒekt kəʊd/ | code objet |
| executable/ɪɡˈzekjʊtəbl/ | exécutable |
| interpreter/ɪnˈtɜːprɪtə/ | interpréteur |
| bytecode/ˈbaɪtkəʊd/ | byte-code |
| portable/ˈpɔːtəbl/ | portable |
| virtual machine/ˈvɜːtʃuːəl məˈʃiːn/ | machine virtuelle |
| just-in-time compilation/dʒʌst ɪn taɪm ˌkɒmpɪˈleɪʃn/ | compilation juste-à-temps |
| integrated development environment/ˈɪntɪɡreɪtɪd dɪˈveləpmənt enˈvaɪrənmənt/ | environnement de développement intégré |
| context-sensitive prompts/ˈkɒntekst ˈsensɪtɪv prɒmpts/ | invitations contextuelles |
| auto-complete/ˈɔːtəʊ kəmˈpliːt/ | autocomplétion |
| dynamic syntax checks/daɪˈnæmɪk ˈsɪntæks tʃeks/ | vérifications syntaxiques dynamiques |
| prettyprint/ˈpretɪprɪnt/ | formatage automatique (prettyprint) |
| breakpoints/ˈbreɪkpɔɪnts/ | points d'arrêt |
| single stepping/ˈsɪŋɡl ˈstepɪŋ/ | pas à pas |
| report window/rɪˈpɔːt ˈwɪndəʊ/ | fenêtre de rapport |
Nobody believed the computer could write its own program
- In 1952 Grace Hopper built the first compiler 编译器, a program that turned a programmer's notation into machine instructions. "Nobody believed that," she said later. "I had a running compiler and nobody would touch it. They told me computers could only do arithmetic."
- Every language you have used since rests on that idea: you write source code 源代码 for people, and a translator produces the machine code 机器码 the processor runs.
- There are three kinds of translator and one famous hybrid, and the exam wants you to say which to use when, and why.
- This lesson is the translators, the trade-offs between compiling and interpreting, Java's mixture of both, and the tools an IDE puts around them.
Personne ne croyait que l'ordinateur pouvait écrire son propre programme
- En 1952, Grace Hopper a construit le premier compilateur 编译器, un programme qui convertissait la notation d'un programmeur en instructions machine. « Personne ne croyait cela », a-t-elle dit plus tard. « J'avais un compilateur fonctionnel et personne ne voulait y toucher. On me disait que les ordinateurs ne pouvaient faire que des calculs arithmétiques. »
- Chaque langage que vous avez utilisé depuis repose sur cette idée : vous écrivez du code source 源代码 pour les humains, et un traducteur produit le code machine 机器码 que le processeur exécute.
- Il existe trois types de traducteurs et un hybride célèbre, et l'examen veut que vous disiez lequel utiliser quand, et pourquoi.
- Cette leçon porte sur les traducteurs, les compromis entre compilation et interprétation, le mélange de Java avec les deux, et les outils qu'un IDE met autour d'eux.
Source code, machine code and the assembler
- The processor executes only machine code. A translator 翻译器 converts a program written for people into it.
- An assembler 汇编器 translates assembly language 汇编语言 into machine code: each mnemonic instruction,
LDD,ADD,JMP, becomes exactly one machine-code instruction, and labels and symbolic addresses are replaced by real addresses. - Assembly is used where the programmer needs direct control of the hardware: device drivers, embedded systems, the innermost loops of a game.
Code source, code machine et assembleur
- Le processeur n'exécute que du code machine. Un traducteur 翻译器 convertit un programme écrit pour les humains en celui-ci.
- Un assembleur traduit le langage assembleur en code machine : chaque instruction mnémonique,
LDD,ADD,JMP, devient exactement une instruction en code machine, et les étiquettes et adresses symboliques sont remplacées par de vraies adresses. - L'assembleur est utilisé là où le programmeur a besoin d'un contrôle direct du matériel : pilotes de périphériques, systèmes embarqués, boucles intérieures d'un jeu.
Match each translator to what it does. · Reliez chaque traducteur à ce qu'il fait.
Assembler: assembly→machine code; compiler: all-at-once to an executable; interpreter: line by line at run time. · Assembleur : assembleur→code machine ; compilateur : tout-en-un vers un exécutable ; interpréteur : ligne par ligne à l'exécution.
The compiler
- A compiler translates the whole high-level program into machine code, object code 目标代码, before it is run. It produces an executable 可执行文件 file and reports all the syntax errors together, as a list, at the end of translation.
- It does not run the program. Once the code is clean, the executable runs without the compiler installed, as many times as you like.
- Fast at run time, since nothing is translated while running; but the machine code is tied to one processor and operating system.
Le compilateur
- Un compilateur traduit le tout le programme haut niveau en code machine, code objet 目标代码, avant qu'il ne soit exécuté. Il produit un exécutable 可执行文件 et signale tous les erreurs de syntaxe ensemble, sous forme de liste, à la fin de la traduction.
- Il n'exécute pas le programme. Une fois le code propre, l'exécutable s'exécute sans le compilateur installé, autant de fois que vous le souhaitez.
- Rapide au moment de l'exécution, car rien n'est traduit pendant l'exécution ; mais le code machine est lié à un seul processeur et système d'exploitation.
The compiler route: source to running program · Le routeur du compilateur : source vers programme exécuté
Step through how a compiler works — translating the whole program once, before it runs. Contrast it with an interpreter, which translates and runs one line at a time. · Étape par étape du fonctionnement d'un compilateur — traduire le programme entier une fois, avant son exécution. Contrastez-le avec un interpréteur, qui traduit et exécute ligne par ligne.
A compiler differs from an interpreter because it: · Un compilateur diffère d'un interpréteur car il :
A compiler translates all at once into an executable that runs without the compiler. An interpreter runs line by line. · Un compilateur traduit l'intégralité du code en un fichier exécutable qui s'exécute sans le compilateur. Un interpréteur s'exécute ligne par ligne.
Put the compiler route in order, from writing code to running it. · Remettez les étapes du flux de compilation dans l'ordre, de l'écriture du code à son exécution.
A compiler translates the whole program once into an executable; that file then runs without the compiler. · Un compilateur traduit tout le programme une seule fois en un exécutable ; ce fichier s'exécute ensuite sans le compilateur.
The interpreter
- An interpreter 解释器 translates one statement of the high-level program at a time and executes it immediately before moving to the next.
- No executable is produced. It stops at the first error it meets and reports it, with the line, so you fix it and run again.
- Both the source code and the interpreter must be present every time the program runs, and each run re-translates, so execution is slower; but the same source runs wherever an interpreter exists.
Translate once and ship, or translate as you go
L'interpréteur
- Un interpréteur 解释器 traduit une instruction du programme haut niveau à la fois et l'exécute immédiatement avant de passer à la suivante.
- Aucun exécutable n'est produit. Il s'arrête à la première erreur rencontrée et la rapporte, avec la ligne, pour que vous la corrigiez et relanciez.
- Le code source et l'interpréteur doivent être présents à chaque exécution du programme, et chaque exécution retraduit, donc l'exécution est plus lente ; mais le même code source fonctionne partout où un interpréteur existe.
Traduire une fois et distribuer, ou traduire au fur et à mesure
When does an interpreter report an error? · Quand un interpréteur signale-t-il une erreur ?
An interpreter runs line by line, so it reports an error at the moment it reaches that line — handy during development. · Un interpréteur s'exécute ligne par ligne, il signale donc une erreur au moment où il atteint cette ligne — pratique pendant le développement.
An interpreter produces no stand-alone executable, so the interpreter itself must be installed to run the program. · Un interpréteur ne produit pas d'exécutable autonome, c'est pourquoi l'interpréteur lui-même doit être installé pour exécuter le programme.
An interpreter translates and runs line by line each time — there is no separate executable to ship, unlike a compiler. · Un interpréteur traduit et exécute ligne par ligne à chaque fois — contrairement à un compilateur, il n'y a pas d'exécutable séparé à distribuer.
Benefits and drawbacks, as the mark scheme lists them
| compiler | interpreter | |
|---|---|---|
| execution speed | fast, already machine code | slower, translated on every run |
| what the user needs | only the executable; the source stays private | the source code and the interpreter |
| finding errors | all listed at once after translation | each reported at its line, as you develop |
| changing the code | recompile the whole program | edit and run again immediately |
| portability | one platform; recompile for each | runs wherever an interpreter exists |
Avantages et inconvénients, selon le barème
| compilateur | interpréteur | |
|---|---|---|
| vitesse d'exécution | rapide, déjà code machine | plus lent, traduit à chaque exécution |
| ce dont l'utilisateur a besoin | uniquement l'exécutable ; le code source reste privé | le code source et l'interpréteur |
| recherche d'erreurs | toutes listées en une fois après la traduction | chacune signalée à sa ligne, au fur et à mesure du développement |
| modification du code | recompiler tout le programme | modifier et relancer immédiatement |
| portabilité | une plateforme ; recompiler pour chaque | s'exécute partout où un interpréteur existe |
You should choose a compiler when: · Vous devriez choisir un compilateur lorsque :
Compiled executables are fast and stand-alone. Interpreters suit quick development and portable scripts. · Les exécutables compilés sont rapides et autonomes. Les interpréteurs conviennent au développement rapide et aux scripts portables.
Which points favour using an interpreter while developing a program? Select all · tout that apply. · Quels points favorisent l'utilisation d'un interpréteur pendant le développement d'un programme ? Sélectionnez tous ceux qui s'appliquent.
Fast edit-run cycles and errors at their line are the interpreter's strengths. Run-time speed is the compiler's. · Des cycles édit-exécuter rapides et des erreurs localisées à leur ligne sont les forces de l'interpréteur. La vitesse d'exécution est celle du compilateur.
Worked example: an interpreter while writing, a compiler when finished
- A developer uses an interpreter while writing a program and a compiler when it is finished. Explain how each is used. [4]
- During development the interpreter runs the partly written program at once, without waiting for a complete translation. When it meets an error it reports the line, so the developer fixes it and runs again immediately: a fast edit-run cycle that makes debugging easier.
- When the program is finished, the compiler translates the whole program into an executable that runs faster, needs no translator on the user's computer, and keeps the source code private.
- Two marks for each tool: what it does, and why that suits that stage.
Exemple résolu : un interpréteur pendant l'écriture, un compilateur une fois terminé
- Un développeur utilise un interpréteur pendant l'écriture d'un programme et un compilateur une fois terminé. Expliquez comment chacun est utilisé. [4]
- Pendant le développement, l'interpréteur exécute le programme partiellement écrit immédiatement, sans attendre une traduction complète. Lorsqu'il rencontre une erreur, il signale la ligne, afin que le développeur la corrige et relance immédiatement : un cycle d'édition-exécution rapide qui facilite le débogage.
- Une fois le programme terminé, le compilateur traduit l'ensemble du programme en un exécutable qui s'exécute plus vite, ne nécessite aucun traducteur sur l'ordinateur de l'utilisateur, et garde le code source privé.
- Deux points pour chaque outil : ce qu'il fait, et pourquoi cela convient à cette étape.
Java: partially compiled, partially interpreted
- Java source is compiled into bytecode 字节码, a compact, portable 可移植的 intermediate form that is not machine code for any real processor.
- A virtual machine 虚拟机, the JVM, then interprets the bytecode on whatever machine it runs on, or uses just-in-time compilation 即时编译 to turn the busiest parts into native code while the program runs.
- The compile stage catches syntax errors early; the interpret stage lets one bytecode file run anywhere a JVM exists. Java in console mode, a text program run from the command line, is the syllabus's example.
Write once, run anywhere: one bytecode file, one JVM per platform
Java : partiellement compilé, partiellement interprété
- Le source Java est compilé en bytecode 字节码, une forme intermédiaire compacte et portable 可移植 qui n'est pas du code machine pour aucun vrai processeur.
- Une machine virtuelle 虚拟机, la JVM, interprète ensuite le bytecode sur n'importe quelle machine sur laquelle il s'exécute, ou utilise la compilation just-in-time 即时编译 pour convertir les parties les plus sollicitées en code natif pendant l'exécution du programme.
- L'étape de compilation détecte précocement les erreurs de syntaxe ; l'étape d'interprétation permet à un seul fichier bytecode de s'exécuter partout où une JVM existe. Java en mode console, un programme texte exécuté depuis la ligne de commande, est l'exemple du programme.
Écrire une fois, exécuter partout : un seul fichier bytecode, une seule JVM par plateforme
Java compiles to bytecode that runs on a JVM. The main benefit is: · Java compile vers du byte-code qui s'exécute sur une JVM. L'avantage principal est :
Bytecode is platform-independent; any JVM can run it (with JIT giving near-native speed for hot code). · Le byte-code est indépendant de la plateforme ; toute JVM peut l'exécuter (avec JIT offrant une vitesse quasi-native pour le code chaud).
Java's compiler produces platform-independent ____, which a virtual machine then interprets. · Le compilateur Java produit un ____ indépendant de la plateforme, qu'une machine virtuelle interprète ensuite.
Bytecode is an intermediate form: compiled once, then run by the JVM on any platform. That is what makes Java partially compiled and partially interpreted. · Le byte-code est une forme intermédiaire : compilé une seule fois, puis exécuté par la JVM sur n'importe quelle plateforme. C'est ce qui rend Java partiellement compilé et partiellement interprété.
Worked example: why compile to bytecode and then interpret?
- Explain why Java is compiled to bytecode rather than straight to machine code.
- A compiler produces machine code for one processor and operating system, so a program compiled on one machine will not run on another.
- Java's compiler targets a virtual machine instead, so the bytecode is identical everywhere. Each platform supplies its own JVM to interpret it.
- The cost is speed: interpreting bytecode is slower than running native code, which is why the JVM adds just-in-time compilation for the hot parts.
Exemple résolu : pourquoi compiler en bytecode puis interpréter ?
- Expliquez pourquoi Java est compilé en bytecode plutôt que directement en code machine.
- Un compilateur produit du code machine pour un seul processeur et système d'exploitation, donc un programme compilé sur une machine ne s'exécutera pas sur une autre.
- Le compilateur Java cible une machine virtuelle, donc le bytecode est identique partout. Chaque plateforme fournit sa propre JVM pour l'interpréter.
- Le coût est la vitesse : interpréter du bytecode est plus lent que d'exécuter du code natif, c'est pourquoi la JVM ajoute la compilation just-in-time pour les parties critiques.
The IDE and its four groups of features
- An integrated development environment 集成开发环境 (IDE) is one application for writing, translating, running and debugging a program. The syllabus groups its features in four.
- For coding: context-sensitive prompts 上下文相关提示 pop up the identifiers, keywords or parameters that fit at that point; auto-complete 自动补全 finishes the name.
- For initial error detection: dynamic syntax checks 动态语法检查 underline a mistake as you type, before translation. For presentation: prettyprint 代码美化 shows keywords, identifiers, strings and comments in different colours with consistent indentation; expand and collapse hides the body of a block so you see the outline.
- For debugging: breakpoints 断点 pause the program at a marked line; single stepping 单步执行 runs one line at a time; a window shows the values of variables and expressions; the report window 报告窗口 lists errors, warnings and output.
Coding, error detection, presentation, debugging
L'IDE et ses quatre groupes de fonctionnalités
- Un environnement de développement intégré 集成开发环境 (IDE) est une seule application pour écrire, traduire, exécuter et débugger un programme. Le programme regroupe ses fonctionnalités en quatre.
- Pour coder : les rappels contextuels 上下文相关提示 font apparaître les identifiants, mots-clés ou paramètres qui conviennent à cet endroit ; l'autocomplétion 自动补létion termine le nom.
- Pour la détection initiale des erreurs : les vérifications dynamiques de syntaxe 动态语法检查 soulignent une erreur alors que vous tapez, avant la traduction. Pour la présentation : le joli affichage 代码美化 montre les mots-clés, identifiants, chaînes et commentaires dans différentes couleurs avec une indentation cohérente ; déplier et replier cache le corps d'un bloc pour voir le plan.
- Pour le débogage : les points d'arrêt 断point suspendent le programme à une ligne marquée ; l'exécution pas à pas 单步执行 exécute une ligne à la fois ; une fenêtre affiche les valeurs des variables et expressions ; la fenêtre de rapport 报告窗口 liste les erreurs, avertissements et sorties.
Codage, détection d'erreurs, présentation, débogage
Which feature is part of an IDE's debugger? · Quelle caractéristique fait partie du débogueur d'un IDE ?
A debugger lets you set breakpoints, step through code line by line, and inspect variable values. · Un débogueur vous permet de définir des points d'arrêt, de parcourir le code ligne par ligne et d'inspecter les valeurs des variables.
Match each IDE feature to its syllabus group. · Reliez chaque fonctionnalité de l'IDE à son groupe de syllabus.
Coding, initial error detection, presentation, debugging: the four groups the syllabus names, one feature each here. · Programmation, détection initiale d'erreurs, présentation, débogage : les quatre groupes nommés par le syllabus, avec une fonctionnalité chacun ici.
Worked example: finding the bug in Calculate()
- A function
Calculate()returns an unexpected value. Describe how the debugging features of an IDE help find the cause. [4] - Set a breakpoint on the first line of
Calculate(), so the program pauses there instead of running through. - Single-step through the function one line at a time. After each step, read the values of the variables and of any expression you have asked the IDE to watch, and compare them with what you expected.
- The first line after which a value is wrong is where the logic error is. The report window shows any run-time error messages and output along the way.
Pause, step, inspect
Exemple résolu : trouver la bug dans Calculate()
- Une fonction
Calculate()retourne une valeur inattendue. Décrivez comment les fonctionnalités de débogage d'un IDE aident à trouver la cause. [4] - Définissez un point d'arrêt sur la première ligne de
Calculate(), afin que le programme y pause au lieu de s'exécuter jusqu'au bout. - Exécutez pas à pas à travers la fonction une ligne à la fois. Après chaque étape, lisez les valeurs des variables et de toute expression que vous avez demandé à l'IDE de surveiller, et comparez-les avec ce que vous attendiez.
- La première ligne après laquelle une valeur est fausse est là où se trouve l'erreur logique. La fenêtre de rapport affiche tout message d'erreur d'exécution et sortie au fil du parcours.
Suspendre, pas à pas, inspecter
Put the steps of finding a logic error with a debugger in order. · Mettez les étapes de recherche d'une erreur logique avec un débogueur dans l'ordre.
Pause, step, inspect, compare, locate. Each is one of the debugging features the syllabus lists. · Pause, pas, inspection, comparaison, localisation. Chacun est une des fonctionnalités de débogage listées dans le syllabus.
Marks that slip away
- A compiler does not run the program. It translates the whole of it and produces an executable.
- An interpreter stops at the first error; a compiler lists them all. Do not swap these.
- "Faster" needs "at run time", and "portable" needs "the same source runs wherever an interpreter exists".
- Sort IDE features into the syllabus's four groups: a breakpoint is debugging, prettyprint is presentation, a context-sensitive prompt is coding. Bytecode is not machine code.
Pièges qui font perdre des points
- Un compilateur n'exécute pas le programme. Il traduit l'intégralité du programme et produit un exécutable.
- Un interpréteur s'arrête à la première erreur ; un compilateur les liste toutes. Ne pas inverser ces rôles.
- « Plus rapide » nécessite « au moment de l'exécution », et « portable » nécessite « le même code source s'exécute partout où un interpréteur existe ».
- Classez les fonctionnalités de l'IDE dans les quatre groupes du programme : un point d'arrêt est du débogage, le joli affichage est de la présentation, un rappel contextuel est du codage. Le bytecode n'est pas du code machine.
You've got it
- assembler: one assembly instruction to one machine-code instruction · compiler: the whole program, before it runs, an executable, all errors listed · interpreter: one statement at a time, executed at once, stops at the first error, no executable
- compiler for speed, distribution and privacy of the source; interpreter for a fast edit-run cycle, portability and beginners
- Java compiles to portable bytecode that a JVM interprets or JIT-compiles: partially compiled, partially interpreted
- IDE features in four groups: coding (context-sensitive prompts), initial error detection (dynamic syntax checks), presentation (prettyprint, expand and collapse), debugging (breakpoints, single stepping, variables, report window)
Vous avez compris
- assembleur : une instruction assembleur vers une instruction de code machine · compilateur : tout le programme, avant l'exécution, un exécutable, toutes les erreurs listées · interpréteur : une instruction à la fois, exécutée immédiatement, s'arrête à la première erreur, pas d'exécutable
- compilateur pour la vitesse, la distribution et la confidentialité du code source ; interpréteur pour un cycle d'édition-exécution rapide, la portabilité et les débutants
- Java compile en bytecode portable qu'une JVM interprète ou JIT-compile : partiellement compilé, partiellement interprété
- Fonctionnalités de l'IDE en quatre groupes : codage (rappels contextuels), détection initiale des erreurs (vérifications dynamiques de syntaxe), présentation (joli affichage, déplier et replier), débogage (points d'arrêt, pas à pas, variables, fenêtre de rapport)