HelpContactFor teachers and institutes
>_StemPy Lab
Mock TestsClasses

>_StemPy Lab

Learn. Solve. Code the solutions. Test yourself.

Live examsFree mock exams, timed and rankedEveryone starts together, and your score and rank come the moment it ends.See the exams →

Learn

  • Physics
  • Chemistry
  • Mathematics
  • Biology
  • Python Programming
  • Statistics & Data Science
  • Computer Science
  • Classes
  • Groups

Practice

  • Problems
  • Quizzes
  • Mock Tests
  • Prepare for an Exam
  • Question Sets
  • Exams
  • Certificates
  • Python Labs
  • AI Practice Generator
  • Student-Created Tests

Community

  • Discussions
  • Resources
  • Notes
  • Glossary
  • Blog

Account

  • Log in
© 2026 senLearn. All rights reserved.HelpFor SchoolsAboutContactPrivacy PolicyTerms of UseRefund Policy
Programming Languages, Translators and IDEs
  1. 1High-level and low-level languages
  2. 2Compilers and interpreters
  3. 3Integrated development environments
  1. Computer Science
  2. /Programming Languages, Translators and IDEs
  3. /High-level and low-level languages

Course 4.3·Lesson 1 of 3

High-level and low-level languages

A processor runs machine code, which is binary. Low-level languages are machine code and assembly language, which uses mnemonics and needs an assembler. High-level languages are closer to English and work on many machines, but cannot work the hardware directly. You compare them and learn the advantages of each.

about 30 min1 simulation1 practice question
Lesson 1 of 3Show all lessonsHide
Programming Languages, Translators and IDEs
  1. 1High-level and low-level languages
  2. 2Compilers and interpreters
  3. 3Integrated development environments

Try the code and the simulations beside the lesson.

The language of the processor

A processor understands one thing: machine code. Machine code is a list of instructions in binary, such as 0010 1111. Each kind of processor has its own set of instructions. Writing a long program as rows of 0s and 1s would be slow, and it is very easy to make a mistake.

So programmers write in other languages, and a translator turns their code into machine code. There are two levels of language.

A ladder of three levels. At the top, High-level language, with the example Total ← Price1 + Price2. In the middle, Assembly language, with the example LDA 14, ADD 15, STO 13. At the bottom, Machine code, with the example 0001 1110. Arrows on the right show that a compiler or an interpreter translates a high-level language, and an assembler translates assembly language, into machine code.

Low-level languages

A low-level language is close to the machine code of the processor. Machine code itself is low level. So is assembly language.

Assembly language uses mnemonics: short words that are easy to remember, such as LDA for "load" and ADD for "add". Each line usually matches one machine code instruction. An assembler is the translator that turns an assembly language program into machine code.

The example below uses a made-up assembly language for a processor with one register, the accumulator, which holds the number being worked on. Real processors have their own mnemonics. The exam does not ask you to learn any set of them.

  • LDA 14 loads the value at memory address 14 into the accumulator.
  • ADD 15 adds the value at address 15 to the accumulator.
  • STO 13 stores the accumulator at address 13.
assembly
LDA 14   // load the value at address 14
ADD 15   // add the value at address 15
STO 13   // store the result at address 13

The assembler turns each line into 8 bits: 4 bits for the operation and 4 bits for the address. Address 14 is 1110 in binary.

binary
0001 1110
0010 1111
0100 1101

High-level languages

A high-level language is closer to English and to mathematics. It uses words such as IF, WHILE and OUTPUT, and one statement can stand for many machine code instructions. Python is a high-level language. So is the pseudocode of the exam. Here is the same addition in Cambridge pseudocode. Pseudocode is shown, not run.

pseudocode
// Add two prices and output the total
Price1 ← 4
Price2 ← 6
Total ← Price1 + Price2
OUTPUT "Total: ", Total

And here it is in Python, in a box you can run.

A high-level program must be translated by a compiler or an interpreter before the processor can run it. That is the next lesson.

Advantages and disadvantages

The syllabus compares the two levels in four ways.

  • Ease of reading and writing code. A high-level language is easier to read and write. Low-level code is hard to read.
  • Ease of debugging code. Mistakes are easier to find and fix in a high-level language.
  • Machine independence. A high-level program can run on different kinds of processor once it is translated for each. A low-level program is written for one kind of processor.
  • Direct manipulation of hardware. A low-level language can work the hardware directly, such as a register or a memory address. A high-level language usually cannot.

Because low-level code works the hardware directly, it can also be made to run fast and use little memory. That is why parts of device drivers and small embedded systems are written in a low-level language.

Try the accumulator

Practise with new numbers

Try it in Python

The program is a tiny assembler and processor. It turns each line of the assembly program into machine code, then runs the program and prints the accumulator after each line.

Read it first. Then run it. Find the machine code of ADD 15. Why does it end in 1111?

1. Change the program to ["LDA 15", "SUB 14", "STO 13"]. Predict the value at address 13, then run it.

2. Add the mnemonic "OUT": "0101" to the table. Which line of the program would use it?

Common mistakes

  • Calling assembly language high level because it uses words. Its mnemonics match machine instructions, so it is low level.
  • Saying an assembler translates a high-level language. It translates assembly language. A compiler or an interpreter translates a high-level language.
  • Saying a high-level language runs directly on the processor. It must be translated first.
  • Giving one side only. A comparison needs a point for each level.

Remember these

  • Machine code is binary. Machine code and assembly language are low-level languages.
  • Assembly language uses mnemonics. An assembler translates it into machine code.
  • High-level languages are easier to read, write and debug, and they are machine independent.
  • Low-level languages can manipulate the hardware directly.

Check yourself

Try each one on your own first. If you are stuck, open a hint. Then check with Show the answer.

  1. What is a mnemonic in assembly language?
  1. Which translator turns assembly language into machine code?
  1. Give one advantage of a high-level language over a low-level language.
  1. Why might a programmer write part of a device driver in a low-level language?
  1. Address 14 holds 4 and address 15 holds 6. What is stored at address 13 after LDA 15, SUB 14, STO 13?

Enroll free in Programming Languages, Translators and IDEs

Every lesson is open to read. Enrolling also lets you:

  • Mark lessons done and carry on where you stopped.
  • Take the tests of this lesson and its course.
  • Count the course towards the certificate for its chapter.
No payment. You can leave at any time.

Problems (4)

Say whether each statement is about a high-level language or a low-level language…Easy · High School (9–10) · by StemPy Lab
A made-up processor has one register, the accumulator…Medium · High School (9–10) · by StemPy Lab
A team writes an app for a school timetable…Medium · High School (9–10) · by StemPy Lab
Next: lesson 2Compilers and interpreters
← Programming Languages, Translators and IDEs
← PreviousCompilers and interpreters →

Discussion (0)

Log in to join the discussion.

Loading…

2 Python programs
5 questions to check yourself

This lesson is free to read. Enroll free to keep your place and take the tests.

A made-up assembler turns each instruction into 8 bits: a 4-bit operation code followed by the…Hard · High School (9–10) · by StemPy Lab

Python Labs (1)

A tiny assemblerPython Lab · by StemPy Lab