Programming Languages and IDEs

All instructions a processor executes are ultimately machine code — binary patterns the hardware understands directly. Programming languages exist at different distances from this machine code.

Level	Examples	Closeness to hardware
High-level language	Python, Java, C#, JavaScript	Far from hardware
Low-level language	Assembly language	Close to hardware
Machine code	Binary (0s and 1s)	IS the hardware instruction set

High-level languages use vocabulary and syntax closer to human language. They are:

• Portable — the same source code can run on different hardware or operating systems (after translation)
• Easier to write and debug — meaningful variable names, readable syntax
• Require translation — a translator converts them to machine code before the processor can run them

Low-level languages (assembly language) use mnemonics that map closely to individual processor instructions. They are:

• Hardware-specific — code written for one processor architecture does not run on a different one
• Efficient — give the programmer fine-grained control over memory and processor registers
• Harder to write and maintain — one high-level statement often replaces dozens of assembly instructions

OCR J277 does not require knowledge of assemblers or assembly language programming — only the characteristics of high-level and low-level languages, and the role of translators.

A processor can only execute machine code (binary instruction patterns). Source code written in any other language — Python, Java, assembly — must be translated into machine code before it can run.

A translator is a program that converts source code written in one language into machine code (or a lower-level intermediate form) that the processor can execute.

Without a translator, a processor cannot understand Python, Java, or any other high-level language. The translator bridges the gap between the human-readable source and the hardware.

Two types of translator are required for OCR J277: compilers and interpreters.

Feature	Compiler	Interpreter
How it works	Translates the entire program before execution	Translates and executes one line at a time
Output	A standalone executable file	No separate file — runs directly
Errors reported	After the whole program is translated	When the problematic line is reached
Execution speed	Faster (already translated)	Slower (translates each line at runtime)
Development use	Better for finished, distributed programs	Better for development and debugging

A compiler translates the entire source program into machine code before execution. The output is a standalone executable file that can be run without the original source code or the compiler.

Compilation process:

1. Developer writes source code
2. Compiler translates the whole file
3. If no errors: executable file is produced
4. Executable runs directly on the hardware

Advantages of compilation:

• Faster execution (translation done once, not at runtime)
• Source code is not needed to run the program — only the executable
• All syntax errors are reported before the program runs

Disadvantages of compilation:

• The executable is platform-specific (compiled for a particular OS/architecture)
• Recompilation required after every code change
• Errors are reported after full translation — harder to locate in large programs

(Extra context — Cython is not required knowledge for OCR J277.) A Python script compiled with a tool like Cython produces a binary that runs faster than the interpreted version and does not require Python to be installed on the target machine.

An interpreter translates and executes source code one line (statement) at a time. No separate executable is produced — the interpreter must be present whenever the program runs.

Interpretation process:

1. Developer writes source code
2. Interpreter reads and executes line 1, then line 2, etc.
3. If a line has an error: execution stops at that line

Advantages of interpretation:

• Easier to debug — errors are reported at the exact line where they occur
• No compilation step — changes can be tested immediately
• More portable — the same source runs on any machine that has the interpreter

Disadvantages of interpretation:

• Slower execution — translation happens at runtime, every time
• The interpreter must be installed on the machine running the program
• Source code is exposed (not compiled to a binary)

Python is typically interpreted, which is why you can run .py files immediately without a compilation step but need Python installed to run them.

An IDE (Integrated Development Environment) is a software application that provides a comprehensive set of tools for writing, testing, and debugging programs — all in one place. OCR J277 requires knowledge of four tools:

Tool	What it does
Editor	A text editor with programming-specific features: syntax highlighting (colour-codes keywords), auto-indentation, auto-complete
Error diagnostics	Identifies and reports syntax and runtime errors; highlights the line where the error occurs; explains the error type
Run-time environment	Executes the program within the IDE so the developer can observe its behaviour immediately
Translator	A built-in compiler or interpreter that converts source code to executable form

How each tool helps a programmer:

• The editor's syntax highlighting lets a developer spot mismatched brackets or misspelled keywords immediately, before running.
• Error diagnostics pinpoint the exact line of a syntax error — without this, a developer would have to scan hundreds of lines manually.
• The run-time environment lets the developer test the program instantly, observe outputs, and step through execution.
• The built-in translator means the developer does not need to run a separate compile command — it is triggered from within the IDE.

(Extra context — specific IDE names are not required by OCR J277 2.5.2; any IDE used in your school is acceptable.) OCR J277 requires practical experience of using these tools within at least one IDE. IDLE (Python's default IDE), PyCharm, and Thonny are commonly used in schools.

Exam questions may ask you to choose between a compiler and an interpreter for a given scenario, or to describe a specific advantage or disadvantage.

Scenario	Better choice	Reason
Developing and testing new code	Interpreter	Immediate error feedback; no compile step between changes
Distributing a finished commercial application	Compiler	Faster execution; no source code exposed; no interpreter needed on user's machine
Learning to program	Interpreter	Errors shown line by line; easier to understand where things go wrong
Running on multiple platforms with different hardware	Interpreter	Source code is portable; interpreter abstracts the hardware differences

Worked example — a company wants to sell software to customers who should not be able to read the source code. Should they use a compiler or interpreter?

A compiler is the better choice: the compiled executable can be distributed without the source code, protecting the company's intellectual property. An interpreted program would require distributing the source (.py) file.

1. Saying compilers are "better" than interpreters

Neither is universally better — they suit different purposes. Compilers produce faster executables; interpreters give better error feedback during development. Describe trade-offs, not a winner.

2. Confusing the translator tool in an IDE with a standalone compiler

An IDE's built-in translator is a compiler or interpreter embedded in the IDE. It does the same job but is integrated with the editor and error diagnostics, so errors are shown inside the IDE rather than in a separate window.

3. Including assemblers in the answer

OCR J277 explicitly states that understanding of assemblers is not required. Do not mention assembly language or assemblers in exam answers about translators.

4. Saying an interpreter "does not report errors"

An interpreter reports errors at the line where they occur. It stops execution and shows the error — it does not silently skip bad lines. The difference from a compiler is when the error is reported: at runtime (interpreter) vs before execution (compiler).

Mistake	Correction
"Compilers are better because they're faster"	Interpreters are better for development; compilers for distribution
"Assembler translates high-level code"	Assemblers translate assembly language (low-level); not required by OCR J277
"Interpreters ignore errors"	Interpreters stop at the line where the error occurs and report it