Language Translators

A processor can only execute machine code. Programs are written as source code, in a language people can read, so all source code programs must be translated into machine code before they can be executed. Assemblers, compilers and interpreters are all types of program translator, but they translate programs in different ways.

High-level languages, such as Visual Basic, C++ and Python, are used to write programs that do not depend on the computer architecture they will run on. To go from high-level source code to executable machine code, the source code must be translated. There are two main ways to do this: compilation or interpretation.

Whether source code is compiled or interpreted depends on the particular implementation of a programming language. Some implementations provide compilers, some provide interpreters, and some provide both.

Low-level language code, that is, assembly language programs, also needs to be translated. The translators used for assembly language programs are called assemblers.

A compiler translates source code into a form that can be executed, but the compiler does not execute the code. It produces executable code that cannot be read by a person or easily reverse-engineered (turned back into source code). Most commercial software is sold as compiled code so that the source code is protected. This helps commercial developers who make money from their code.

The compiler takes the source code and puts it through a series of processes to produce executable code:

• lexical analysis
• syntax analysis
• semantic analysis
• code generation
• optimisation.

Note These stages of compilation are taught at A Level, in 16.2 Translation software.

Any compilation errors are reported at the end of the compilation process. This is a disadvantage for large programs, because errors may be linked to each other. If errors are found, the program has to be corrected and compiled again, and this is repeated until the program is free of errors.

Once the program has compiled successfully, the executable file does not need to be translated again (unless the source code is changed). This makes it run faster, because no more translation is needed, which is a particular advantage for programs where performance is critical, such as fast-moving games.

Another advantage of a compiler is that the user does not need a translator (an interpreter) installed on their computer, because they never need to translate the program themselves. However, a Visual Basic program compiled to run on an Intel processor, for example, would need to be recompiled to run on an Apple processor.

For a compiler, these steps apply:

1. The compiler program and the source code file are made available, but no data is needed.
2. The compiler program begins execution.
3. The first line of the source code is read.
4. The line is analysed.
5. If an error is found, this is recorded.
6. If no error is found, the line of source code is converted to an intermediate code.
7. The next line of source code is read and steps 4 to 7 are repeated.
8. When the whole of the source code has been dealt with, one of two things happens. If no error has been found in the whole source code, the complete intermediate code is converted into object code. If any errors have been found, a list of them is output and no object code is produced.

The program can only be executed once compilation has shown no errors. This can happen straight away under the control of the compiler, if data for the program is available. Otherwise the object code is stored, and the program is executed later with no involvement of the compiler.

An interpreter translates and executes each line of source code, one line at a time. Each program line, when it is run, is first syntax-checked. If a syntax error is found, such as a missing bracket, the program stops and the error is reported. After the syntax check, the interpreter converts the line into its machine code equivalent and executes it. If a run-time error happens, the program crashes.

This line-by-line approach lets the developer test the program and quickly find and fix each error as it happens, without translating the whole program every time. So interpreters are very useful while a program is being developed.

Interpreted source code runs more slowly than compiled code, because it must be translated all over again every time the program is run. Also, the user must have the interpreter installed to run the program. However, interpreted code helps if the programmer does not know which platform will run the code. For example, JavaScript code is interpreted: the translation is done by the browser on the user’s computer.

For an interpreter, these steps apply:

1. The interpreter program, the source code file and the data to be used by the source code program are all made available.
2. The interpreter program begins execution.
3. The first line of the source code is read.
4. The line is analysed.
5. If an error is found, it is reported and the interpreter program stops execution.
6. If no error is found, the line of source code is converted to an intermediate code.
7. The interpreter program uses this intermediate code to execute the required action.
8. The next line of source code is read and steps 4 to 8 are repeated.

Whether a compiler or an interpreter is used depends on the programming language. For example, PHP programs (used to create dynamic web pages) are interpreted. When choosing between a language that can be compiled and one that can be interpreted, the programmer should weigh up the benefits and drawbacks of each.

These tables give the reasons to choose each translator, comparing the two side by side.

Why a compiler should be used rather than an interpreter:

Why an interpreter should be used rather than a compiler:

Some high-level languages are partially compiled and partially interpreted. Most interpreted languages now use bytecode as an intermediate stage to speed up translation. The source code is compiled to produce bytecode (a low-level code), which is then interpreted (translated and executed) by a virtual machine.

Java works like this in console mode. A Java program is first compiled into Java bytecode. The bytecode is not the machine code of any real processor. When the program is run, the Java Virtual Machine on the user’s computer interprets the bytecode for that computer’s processor.

An assembler translates assembly code programs into executable code. Because assembly code is specific to a type of processor, assemblers are specific too.

There is a one-to-one relationship between assembly code and machine code: each assembly instruction becomes one machine code instruction. So, compared with compiling high-level source code, assembling is a fairly simple translation. Any comments in an assembly code program are removed by the assembler, and symbolic references such as labels are replaced with actual addresses.

An integrated development environment (IDE) is used by programmers to help them write and develop programs. There are many different IDEs: some support just one programming language, others can be used for several. NetBeans, PyCharm, Visual Studio and SharpDevelop are all IDEs in use today.

IDEs usually have:

• a source code editor
• a compiler, an interpreter, or both
• a run-time environment with a debugger
• an auto-documenter.

A source code editor lets a program be written and edited without using a separate text editor. An integrated source code editor speeds up development, because editing can be done without switching to a different piece of software every time the program needs correcting or adding to.

• Prettyprint: most source code editors colour code the words in the program and lay the program out in a meaningful way, such as indenting code blocks. This is called prettyprinting.
• Context-sensitive prompts: as the code is typed, the editor suggests ways to complete it, with text completion for variable names and reserved words.
• Dynamic syntax checks: the editor checks the syntax as the code is typed.

The figures show these features in the PyCharm source code editor.

Dynamic syntax checking finds possible syntax errors while the program code is being typed into the source code editor, and alerts the programmer straight away, before the program is translated and run. So many errors can be found and corrected while the program is being written and edited, before it is run. Logic errors can only be found when the program is run.

Expand and collapse code blocks: in larger programs with more than one code block, some code blocks can be collapsed to a single line in the editor, so the programmer sees only the blocks being worked on. A collapsed block can be expanded again to show all its code.

Most IDEs provide a compiler, an interpreter or both, to run the program. The interpreter is often used while developing the program, and the compiler to produce the final version of the object code.

With PyCharm there can be more than one interpreter, for different versions of the Python language. The program results are shown in the run-time environment provided.

A debugger is a program that runs the program being developed and helps with debugging (finding and correcting errors). It lets the programmer:

• single step through the program, running it one line at a time (single stepping), so the effect of each line can be seen
• set a breakpoint, which stops the program running at a chosen line of the source code.

A report window then shows the contents of the variables, and the values of expressions, at that point in the program. This lets the programmer look for logic errors and check that the program works as intended.

Each variable used is shown in the report window together with its data type and its contents at that point in the program. Answers to calculations and other expressions can also be shown.

Most IDEs provide an auto-documenter, which explains the function and purpose of programming code.