Stretch tasks Classification of Programming Languages

Round 1: Quiz Blitz

1. Assembly language Low-level languages are machine code and assembly language.
2. Many machine instructions That one fact explains why high-level code is quick to write and gives less direct control.
3. Assembler Each assembly mnemonic becomes one machine instruction.
4. False It executes as it translates, so no executable is made.
5. Compiler Customers receive only the executable.
6. Device drivers; Embedded systems with very little memory Wherever direct hardware control or tiny memory use is worth the effort.
7. Machine code Everything else must be translated into machine code.
8. portability High-level languages are portable. Low-level code is written for one processor family.
9. It is translated every time it runs, even inside loops Every run, and every time round a loop, each line is translated again.
10. True An assembler turns its mnemonics into machine code.
11. LDA LDA, ADD and STA are short mnemonics for machine instructions.
12. Python → Assembly language → Machine code High-level, then mnemonics, then pure binary.

Round 2: Quick Fire

1. • Errors are reported line by line, as they are met
   • So faults are quicker to find and fix
   Model answer

   An interpreter reports each error as soon as the line is reached, which makes faults far quicker to find and fix during development.

2. • The executable is machine code for one type of processor
   • A different type of machine needs its own compiled version
   Model answer

   The executable is machine code for one type of processor, so a different type of machine needs the program compiled again, as a separate version.

3. • It gives direct control of the hardware and its registers
   • It can be optimised for speed and memory
   Model answer

   A device driver must talk directly to specific hardware registers, which assembly language allows, and the code can be optimised precisely for speed and memory.

4. • It translates assembly language into machine code
   • Each mnemonic becomes one machine instruction
   Model answer

   An assembler translates assembly language into machine code. The relationship is close to one to one: each mnemonic becomes one machine instruction.

Round 3: Big Think

1. • High-level: close to English, easy to read
   • High-level: portable
   • High-level: quick to develop in
   • One high-level statement becomes many machine instructions
   • Low-level: hard to read and slow to write
   • Low-level: written for one processor family
   • Low-level: complete control of the hardware
   • Low-level: can be optimised precisely
   Model answer

   High-level languages are close to English, so they are easy to read, and they are portable, running on any machine with a translator. They are quick to develop in, because one statement becomes many machine instructions, and memory is managed for you. Low-level languages are hard to read and slow to write, and they are written for one processor family. But they give complete, direct control of the hardware and can be optimised precisely for speed and memory, which is why they are used for device drivers and embedded systems.

2. • While developing: errors reported line by line make debugging quicker
   • To distribute: compile to an executable
   • The executable runs quickly
   • Players need no translator, and the source code stays private
   Model answer

   While developing, an interpreter is better, because it reports errors line by line as they are met, which makes debugging quicker. To distribute the game, a compiler should be used to produce an executable: it runs quickly, the players need no translator, and the source code is not given away, which protects the company's work.

This or That

1. Python source code High-level code is portable. Machine code only runs on its own processor family.
2. The finished program The compiled executable runs with no translation at all.
3. No: it uses mnemonics and must be assembled Assembly replaces binary opcodes with mnemonics, which an assembler translates.
4. The language, for you In low-level languages, managing memory is the programmer's job.
5. Low-level languages That control is why they are still used for drivers and embedded systems.
6. It is often all they have Malware arrives as an executable, without its source code.
7. An interpreter Interpreted programs are translated on the user's machine every time they run.
8. Assembly mnemonics Short mnemonics stand in for binary opcodes.

Memory Match

• A 3 High-level language: Close to human language
• B 1 Machine code: Binary the processor executes
• C 2 Assembly language: Mnemonics in place of binary opcodes
• D 6 Compiler: Whole program, translated once
• E 4 Interpreter: Translates one statement at a time
• F 5 Portability: Running on different types of computer

Sort It

1. Low-level Can be optimised precisely for speed The programmer decides every instruction.
2. High-level Quick to write, as one statement does a lot One statement becomes many machine instructions.
3. High-level Python, C# and VB.NET All three are high-level languages.
4. Low-level Complete, direct control of the hardware That is why low-level languages are still used.
5. High-level Portable: runs on any machine with a translator High-level code is not tied to one processor.
6. High-level Close to English, so easy to follow High-level languages are written for people.
7. Low-level Used for device drivers Drivers must talk directly to hardware registers.
8. High-level Memory is managed for you The language handles memory.
9. Low-level Machine code and assembly language These are the two low-level languages.
10. Low-level Written for one processor family Low-level code uses one processor's instruction set.
11. Low-level The programmer manages memory Nothing is handled for you.