5.2 Language Translators

### Translator
- converts a high-level / low-level language code to the binary language code which machines can understand.
##### Assemblers
- The software translates low-level statements into machine code(object code / binary) for the processor to execute.
- The mnemonics used translates into machine opcodes
- Process simple because assembly language has a one-to-one relationship with machine code.
##### Compiler
- A compiler is a complex piece of software whose job is to convert source code to machine understandable code (or binary code) in one go.
- The software reads the source code and reports all errors. The software produces an executable file.
###### Operation
- Attempts to translate the whole source code
- Creates a separate error report at the end of the translation process
- If translation successful / no errors creates an executable file
###### Benefits
- Once translated the compiler software is not needed to run the program
- Compiled code should execute faster
- Compiler produces an executable file
- The executable file produced by a compiler can be distributed without users having sight of the source code // source code is kept secure // users are unable to make changes to the program
- Cross-compilation is possible
###### Drawbacks
- larger amounts of source code take time to compile
- slower to produce the object code than an interpreter
- code cannot be changed without recompilation
- the program will not run if there are any errors
- errors cannot be corrected in real-time
- one error may result in other false errors being reported
- cannot easily test specific sections of the source code // cannot easily test unfinished source code
##### Interpreter
- An interpreter is a software program written to translate source code to machine code but it does that line by line.
###### Operation
- Reads each line then translates it and executes it
- Stops when an error is encountered // displays errors where it finds them
###### Benefits
- Easier de-bugging
- The interpreter stops when error encountered
- error can be corrected in real time
- The interpreter translates a statement then executes it immediately
- Parts of the program can be tested, without all the program code being available.
###### Drawbacks
- Source code is needed at run time 
- No executable file produced, (so source code can be edited)
- Translation software needed every time the program is run
- execution time increased
##### Hybrid approach (partially compiled and partially interpreted)
- Best of both the world - compiler and interpreter.
- Code privacy from compilation and portability from interpretation.
###### Benefits
- partially compiled programs can be used on different platforms as they are interpreted when run
- code is optimised for the CPU as machine code is generated at run time
###### Drawbacks
- Intermediate code / program still needs to be interpreted on the user's computer, which may run slowly 
- Extra CPU resources may be required
#### Integrated Development Environment
- Coding
  - Context-sensitive prompts: Displays choice of keywords and available identifiers appropriate at current insertion point and provides choices in alphabetical order
  - Highlights undeclared/unassigned variable identifiers
- Initial Error Detection
  - Dynamic syntax checks: Automatic checking and highlighting of syntax errors, as soon as line typed
  - Type checking & parameter checking
- Presentation
  - Prettyprint: Automatic indentation and color-coding of keywords
  - Expand and Collapse code blocks: Saves excessive scrolling if collapsed, and easy to see global variable declarations and main program body when collapsed
- Debugging
  - Single stepping: Executes program line-by-line to see the effect of each statement on variables
  - Breakpoints: Pauses program at a specific line to ensure program operates correctly up to that line
  - Variables/expressions Report Window: Monitors variables for comparing values.