Types of programming language, translators and integrated development environments Revision Notes

Programming languages are tools that allow humans to write instructions for computers. These languages vary in their level of abstraction from the hardware. Two main categories are high-level and low-level programming languages, each serving different purposes depending on the needs of the programmer and the application.

• High-level languages are closer to human languages and abstract away hardware details.
• Low-level languages are closer to machine code and provide direct hardware control.

High-level languages use syntax and commands that are easier for humans to understand and write. They abstract away the complexities of the computer's hardware, allowing programmers to focus on solving problems rather than managing hardware specifics.

Examples include Python, Java, and C++. These languages often include features like variables, loops, and functions that resemble natural language or mathematical notation.

Because they are machine-independent, high-level programs can run on different types of hardware with minimal changes, provided an appropriate translator (compiler or interpreter) is available.

• Code is more readable and maintainable.
• Debugging is generally easier due to clearer syntax and error messages.
• Programs are portable across different hardware platforms.
• Execution speed may be slower due to translation overhead and abstraction layers.

Low-level languages operate closer to the hardware, offering little abstraction. They include machine code (binary instructions executed directly by the CPU) and assembly language, which uses mnemonic codes to represent machine instructions.

These languages allow precise control over hardware resources such as memory and processor registers, enabling highly efficient and fast programs.

However, low-level code is harder to read and write, making debugging more complex and time-consuming. Additionally, low-level programs are usually specific to a particular type of hardware and are not portable.

• Direct hardware manipulation enables optimized performance.
• Programs execute faster due to minimal translation.
• Code is difficult to read and write, increasing development time.
• Debugging is challenging because of cryptic instructions and lack of abstraction.
• Programs are hardware-dependent and less portable.

High-level languages use descriptive keywords and structured syntax, which makes understanding and modifying code easier. For example, a loop in Python might be written as 'for i in range(5):', which is intuitive.

In contrast, low-level languages use numeric codes or short mnemonics like 'MOV' or 'ADD', which require detailed knowledge of the processor's instruction set.

Debugging high-level code benefits from meaningful error messages and tools integrated into development environments. Low-level debugging often requires examining memory addresses and register contents, which is more complex and error-prone.

• High-level: easier to read and debug due to abstraction and meaningful syntax.
• Low-level: harder to read and debug due to cryptic instructions and hardware focus.

High-level languages are designed to be machine-independent, meaning the same source code can run on different hardware platforms with little or no modification. This is achieved through translators like compilers and interpreters that convert high-level code into machine-specific instructions.

Low-level languages interact directly with hardware, making them highly dependent on the architecture of the target machine. This allows for fine-tuned control but limits portability.

For example, assembly language written for an Intel processor will not run on an ARM processor without rewriting or adapting the code.

• High-level languages promote portability and ease of maintenance.
• Low-level languages provide precise hardware control but lack portability.

Choosing between high-level and low-level programming languages depends on the requirements of the project.

High-level languages improve productivity, code clarity, and portability but may sacrifice execution speed and hardware control.

Low-level languages enable efficient use of system resources and faster execution but require more effort to write and maintain, and are less portable.

• High-level: + Readable, portable, easier debugging; - Slower execution, less hardware control.
• Low-level: + Fast execution, hardware control; - Difficult to read/debug, hardware-dependent.

Assembly language is a type of low-level programming language that provides a symbolic way to write instructions that a computer's processor can execute. Unlike high-level languages, which use English-like syntax, assembly language uses short codes called mnemonics to represent individual machine instructions.

Each mnemonic corresponds directly to a specific machine code instruction, making assembly language closely tied to the architecture of the CPU. For example, the mnemonic 'ADD' might represent an instruction to add two numbers, while 'MOV' could mean moving data from one location to another.

Because assembly language is so close to machine code, it allows programmers to write instructions that control hardware precisely and efficiently. However, it requires detailed knowledge of the processor's instruction set and architecture.

• Assembly language uses mnemonics as symbolic codes for machine instructions.
• It is specific to a particular CPU architecture.
• It provides a human-readable form of machine code instructions.

Mnemonics are short, memorable codes that represent machine instructions or operations. They simplify programming by replacing binary machine code with understandable text.

For example, instead of writing the binary code '10110000' to move data, a programmer writes 'MOV'. Other common mnemonics include 'SUB' for subtraction, 'JMP' for jump (branching), and 'CMP' for compare.

Mnemonics are often accompanied by operands, which specify registers, memory addresses, or immediate values. For instance, 'MOV A, 5' might mean move the value 5 into register A.

• Mnemonics represent machine instructions symbolically.
• They make programming in assembly language more manageable than writing raw binary.
• Operands specify the data or addresses involved in the instruction.

Assembly language is classified as a low-level language because it operates very close to the hardware. It provides little abstraction from the machine's binary instructions, unlike high-level languages that abstract away hardware details.

This proximity means assembly language programs are specific to a particular processor type and architecture. They are not portable across different CPUs without modification.

Low-level languages like assembly allow direct manipulation of hardware resources such as registers and memory addresses, enabling efficient and precise control.

• Assembly language corresponds closely to machine code instructions.
• It is hardware-specific and not portable across different CPU architectures.
• It allows direct control over hardware components.

An assembler is a software tool that translates assembly language code into machine code, which is a binary format the CPU can execute directly.

The assembler reads the mnemonics and operands, converts each instruction into its corresponding machine code, and outputs an object file or executable.

For example, the assembly instruction 'MOV A, 5' might be translated into a specific binary code that the processor understands as moving the value 5 into register A. Without an assembler, the CPU cannot execute assembly language programs because it only understands machine code.

• An assembler converts assembly language into machine code.
• It translates mnemonics and operands into binary instructions.
• The output is executable by the CPU.

Consider a simple task: adding two numbers stored in registers and storing the result in another register.

Assembly code might look like: 'MOV A, 10' (move 10 into register A), 'MOV B, 20' (move 20 into register B), 'ADD A, B' (add contents of B to A).

The assembler converts these instructions into machine code, such as binary sequences, which the CPU executes to perform the addition operation directly at the hardware level.

• Assembly instructions use mnemonics and operands to specify operations.
• The assembler translates these into machine code.
• The CPU executes the machine code to perform the task.

High-level programming languages, such as Python, Java, or C++, are designed to be readable by humans but cannot be directly executed by a computer's processor. To run a program written in a high-level language, it must first be translated into machine code — the binary instructions understood by the hardware. This translation is performed by special software called translators, primarily compilers and interpreters. Understanding how these translators work is essential for effective programming and debugging.

• High-level languages are human-readable but not directly executable by computers.
• Translators convert high-level code into machine code.
• Compilers and interpreters are the two main types of translators.

A compiler processes the entire high-level program in one operation. It reads the source code, checks it for syntax errors, and translates it into a complete machine code program, often called an executable file. This executable can then be run independently of the compiler. The compilation process involves several stages: lexical analysis, syntax analysis, semantic analysis, optimization, and code generation.

If errors are found during compilation, the compiler reports them all after scanning the entire program, listing the line numbers and types of errors. The programmer must fix these errors and recompile before the program can run. Because the whole program is translated at once, compilation can take some time, but the resulting executable runs quickly since it is already in machine code.

• Compiler translates entire program before execution.
• Generates an executable machine code file.
• Reports all syntax errors after full compilation.
• Executable runs independently of the compiler.

An interpreter translates and executes high-level code one line or statement at a time. It reads a line, translates it into machine code, executes it immediately, then moves to the next line. This process continues until the program finishes or an error occurs.

When the interpreter encounters an error, it stops execution and reports the error immediately, specifying the line and nature of the problem. This immediate feedback is useful during program development and debugging, allowing programmers to test and correct code incrementally. However, interpreted programs generally run slower than compiled ones because translation happens during execution.

• Interpreter translates and executes code line by line.
• Stops and reports errors immediately when encountered.
• Useful for incremental testing and debugging.
• Programs run slower compared to compiled executables.

The timing and style of error reporting differ significantly between compilers and interpreters. A compiler analyses the entire program first, then provides a list of all detected errors, which helps identify multiple issues in one go but requires recompilation after fixes.

In contrast, an interpreter reports errors as soon as they occur during execution, allowing the programmer to fix errors one at a time. This approach is helpful for beginners or during development but can be inefficient for large programs with many errors.

For example, if a program has syntax errors on lines 5 and 20, a compiler will report both after compilation, while an interpreter will stop at line 5 and report that error first, requiring correction before proceeding.

• Compiler reports all errors after full program analysis.
• Interpreter reports errors immediately when encountered.
• Compiler approach suits final program translation.
• Interpreter approach suits development and debugging.

Consider a simple program that prints numbers from 1 to 5. Using a compiler, the entire program is translated into machine code before running. If there is a missing semicolon on line 3, the compiler will report this error after scanning the whole program, preventing execution until fixed.

Using an interpreter, the program runs line by line. When it reaches line 3 with the missing semicolon, the interpreter stops and reports the syntax error immediately, allowing the programmer to correct it before continuing.

This difference means interpreters are often used during development for quick testing, while compilers are preferred for producing efficient, standalone executables for distribution.

• Compiler requires full program to be error-free before execution.
• Interpreter allows step-by-step execution and debugging.
• Choice depends on development stage and performance needs.

High-level programming languages are designed to be readable by humans but cannot be executed directly by a computer's processor. To run a program, its source code must be translated into machine code, which the hardware understands. This translation is performed by software tools called translators, primarily compilers and interpreters. Understanding their differences is essential for effective software development and optimisation.

• High-level code must be translated to machine code before execution.
• Translators automate this conversion process.
• Compilers and interpreters are the two main types of translators.

A compiler processes the entire source code of a program at once, translating it into a complete machine code file before any part of the program runs. This machine code can then be executed directly by the computer's processor without further translation. Because the whole program is translated ahead of time, the resulting executable runs quickly and efficiently.

However, since the compiler requires the entire program to be free of syntax errors before producing machine code, developers cannot test or run parts of the program until compilation succeeds. This can slow down the debugging process, especially for large programs.

• Compiles entire source code into machine code before execution.
• Produces a standalone executable file.
• Results in faster program execution.
• Requires error-free code before compilation completes.

An interpreter translates and executes source code one statement at a time. It reads a line of code, translates it into machine instructions, executes it immediately, then moves on to the next line. This approach allows developers to test and debug code interactively, as errors are reported as soon as the problematic line is reached.

Because the interpreter translates code during execution, the program runs more slowly compared to compiled code. Also, the interpreter must be present on the machine running the program, as it performs translation on the fly.

• Translates and executes code line-by-line.
• Allows immediate testing and debugging.
• Slower execution compared to compiled code.
• Requires the interpreter to be installed on the target machine.

Choosing between a compiler and an interpreter depends on the stage of development and the goals of the programmer. Compilers produce fast, standalone executables suitable for final software releases, but they make debugging slower since the entire program must compile successfully before running.

Interpreters facilitate rapid development and testing by executing code immediately and providing instant feedback on errors. This makes them ideal during the development phase. However, interpreted programs run slower and depend on the interpreter's presence, which can be a limitation for distribution.

• Compiler advantages: fast execution, standalone executables.
• Compiler disadvantages: slower debugging, requires full program compilation.
• Interpreter advantages: immediate execution, easier debugging.
• Interpreter disadvantages: slower execution, dependency on interpreter software.

During program development, interpreters are commonly used because they allow programmers to write, test, and debug code incrementally. Errors can be identified and fixed quickly without waiting for a full compilation.

Once the program is complete and tested, a compiler is used to translate the entire source code into an efficient executable file. This final compiled program runs faster and can be distributed without requiring the original source code or an interpreter.

• Interpreters are preferred during development for flexibility and quick error detection.
• Compilers are used for final program translation to improve performance and portability.
• Combining both tools can optimise development and deployment workflows.

An Integrated Development Environment (IDE) is a software application that provides programmers with a comprehensive set of tools needed to develop software efficiently. Instead of using separate programs for writing code, compiling, running, and debugging, an IDE combines these functions into a single interface. This integration reduces the complexity of managing multiple tools and helps programmers focus on coding.

IDEs are widely used in software development because they streamline the workflow, reduce errors, and speed up the development process. Examples of popular IDEs include Visual Studio, Eclipse, and PyCharm.

• Combines multiple programming tools into one application.
• Simplifies the coding, testing, and debugging process.
• Improves productivity and reduces errors.

The code editor is the primary feature of an IDE where programmers write and modify their source code. Unlike a simple text editor, an IDE’s code editor offers advanced capabilities that make coding faster and less error-prone.

For example, syntax highlighting colours keywords, variables, and symbols differently, making the code easier to read and understand. Line numbering helps locate specific parts of the code quickly. The editor also supports indentation and bracket matching, which help maintain proper code structure.

Example: When writing a Python function, the IDE highlights 'def' in a distinct colour and automatically indents the following lines, helping the programmer maintain correct syntax.

• Supports writing and editing source code efficiently.
• Includes syntax highlighting and line numbering.
• Helps maintain code structure with indentation and bracket matching.

An IDE provides a runtime environment that allows programmers to run their code directly within the application. This feature enables immediate testing without switching to external programs.

Running code inside the IDE helps catch errors early and observe program behaviour in real time. For example, a student writing a simple calculator program can run it inside the IDE to check if it correctly adds or subtracts numbers.

This integration saves time and makes debugging more straightforward because the programmer can quickly modify the code and rerun it.

• Allows code execution within the IDE.
• Facilitates immediate testing and observation of program behaviour.
• Speeds up the development and debugging cycle.

Most programming languages require source code to be translated into machine code before execution. IDEs often include built-in translators such as compilers or interpreters.

A compiler translates the entire high-level program into machine code before running it, producing an executable file. An interpreter translates and executes code line-by-line, which is useful for testing and debugging.

For example, when using a C++ IDE, the compiler converts the source code into an executable program. In contrast, a Python IDE uses an interpreter to run the code directly. The IDE manages these translation processes seamlessly, so the programmer does not need to run separate commands.

• Includes tools to translate high-level code into machine code.
• Supports compilers (full translation) and interpreters (line-by-line execution).
• Automates the translation process within the development workflow.

One of the most valuable features of an IDE is its ability to detect errors in code and provide diagnostics. This includes syntax errors, semantic errors, and sometimes logical errors.

The IDE highlights errors as the programmer types, often underlining mistakes in red or showing warning icons. It may also provide messages explaining the error and suggestions for correction.

For example, if a programmer forgets a semicolon in Java, the IDE will flag this immediately, allowing the programmer to fix it before running the program. This reduces debugging time and helps beginners learn correct syntax.

• Detects syntax and semantic errors in real time.
• Highlights errors and provides diagnostic messages.
• Helps programmers correct mistakes early in development.

Auto-completion suggests possible code completions as the programmer types, reducing typing effort and preventing spelling mistakes. For example, typing 'pri' might prompt the IDE to suggest 'print()' in Python.

Auto-correction automatically fixes common errors, such as missing brackets or misspelled keywords, improving code accuracy.

Pretty printing formats the code neatly by adjusting indentation, spacing, and line breaks, making the code easier to read and maintain. This is especially useful when working in teams or revisiting code after some time.

• Auto-completion speeds up coding by suggesting code snippets.
• Auto-correction fixes common syntax errors automatically.
• Pretty printing formats code for better readability and consistency.