Programming languages

Introduction: Talking to Computers

Have you ever wondered how a computer knows exactly what to do when you click a button or play a game? Computers don't speak English or any other human language. They only understand electricity—either "on" or "off." To bridge the gap between us and the computer, we use programming languages. In this section, we will explore the different levels of these languages and the "translators" that turn our instructions into something a computer can actually use.

High-Level and Low-Level Languages

Not all programming languages are created equal. Some are designed to be easy for humans to read, while others are designed to be exactly what the computer's processor needs.

1. High-Level Languages

Most of the programming you do in school (like using Python) is in a high-level language. These are designed to be "human-friendly."

• Characteristics: They use English-like words (e.g., print, if, while) and follow a logical structure.
• Portability: They are portable, meaning the same code can often run on different types of computers (e.g., a Mac, a Windows PC, or a Linux machine).
• Purpose: They allow programmers to write complex programs quickly without worrying about how the computer's hardware works.

Example: Python, Java, C++, and Javascript.

2. Low-Level Languages

Low-level languages are much closer to what the computer hardware actually understands. There are two main types:

• Machine Code: This is the ultimate low-level language. It consists entirely of binary (0s and 1s). This is the only language the CPU can actually "read" and execute directly.
• Assembly Language: This is one step up from machine code. It uses short mnemonics (memory aids) like ADD, SUB, or MOV. It is usually used for specific hardware tasks, like writing the software for a microwave or a digital watch.

Characteristics of Low-Level Languages:
- They are very difficult for humans to read and write.
- They are not portable; code written for one specific CPU might not work on another.
- They give the programmer total control over the computer's memory and hardware.

Don't worry if this seems tricky at first!

Just think of it like this: High-level is like talking to a friend in English. Low-level is like giving a robot a list of every single gear it needs to turn and every wire it needs to spark.

Quick Review: Key Differences

High-Level: Easy to read, portable, needs translating, slower to run.
Low-Level: Hard to read, specific to hardware, very fast to run.

Key Takeaway: High-level languages favor human understanding, while low-level languages favor the computer's hardware efficiency.

Translators: Compilers and Interpreters

Since the CPU can only understand machine code (0s and 1s), any program written in a high-level language must be translated. There are two main ways to do this: using a compiler or an interpreter.

1. Compilers

A compiler takes the entire source code (the instructions you wrote) and translates it all at once into an executable file (like an .exe file).

• How it works: It scans the whole program and produces a complete machine code version.
• Speed: The translation takes time, but once it is finished, the program runs very quickly.
• Privacy: You don't need to send your original source code to the user; you just send the "compiled" machine code.
• Errors: If there is even one error, the compiler will stop and won't finish the translation until you fix it.

2. Interpreters

An interpreter translates the source code one line at a time and executes it immediately.

• How it works: It reads line 1, translates it, and runs it. Then it moves to line 2.
• Speed: The program starts running instantly, but it runs slower overall because it is translating "on the fly."
• Debugging: It is great for beginners! If there is an error on line 10, the program will run lines 1-9 perfectly and then stop exactly where the mistake is.
• Requirement: The user must have the interpreter software installed on their computer to run the program.

Did you know?

Python is an interpreted language! That's why you can run your code instantly in your IDE and see the results line by line.

Comparing the Two: An Analogy

Imagine you have a recipe written in French, but you only speak English.

• The Compiler is like a professional translator who takes the whole French recipe and writes a brand new version in English. You can now use that English version whenever you want without the translator being there.
• The Interpreter is like a friend sitting in the kitchen with you. They read one line in French, tell you what it says in English, wait for you to do it, and then move to the next line. If they find a word they don't know, they stop right there!

Common Mistake to Avoid

Students often think a compiler "runs" the program. It doesn't! It creates a separate file that can be run later. The interpreter is the one that actually executes the code as it translates it.

Key Takeaway: Compilers translate everything at once to create a fast, independent file. Interpreters translate line-by-line, making them better for testing and finding mistakes.

Summary of Topic 3.3

• High-level languages (like Python) are English-like and portable across different computers.
• Low-level languages (Machine Code and Assembly) are hard for humans but fast for CPUs.
• Machine Code is the only thing the CPU understands (binary).
• Compilers translate the whole program at once into a file that runs fast.
• Interpreters translate line-by-line, which is slower but makes finding errors (debugging) much easier.