🧱 A Look Inside Low-Level Programming: Understanding Computer Thinking, Step by Step
This article is part of the Software Development Series — where we break down how software works, how programmers communicate with computers, and what happens behind the scenes when code runs. 👉 — Software Development: Modern Software Basics.
Assembly Language can get really deep — the deep where even experienced programmers grab an extra coffee. But don’t worry! This article is the beginner-friendly tour, not the “lost in a sea of 1s and 0s” version. We’ll keep things simple, clear, and perfectly human-readable.
Whenever a programmer writes code, they’re really giving instructions to the computer’s processor. Assembly Language is the closest that humans ever get to speaking the processor’s “native” language. It allows developers to give very precise, step-by-step instructions directly to the hardware.
It’s called Assembly because after the programmer writes it, another tool — an assembler — converts it into the 1s and 0s the computer understands. And because every processor family (Intel, AMD, ARM, etc.) works differently, Assembly code written for one type of chip will look completely different on another.
Assembly has been around for a long time. It was first created in the late 1940s and became the main way to write programs in the early decades of computing. Early operating systems, popular spreadsheet programs, and even classic video games were written in Assembly because it gave programmers complete control over the machine.
As newer, easier programming languages appeared, Assembly became less common — but it never fully went away. Today, it’s still used when speed, precision, or very low-level hardware access is required. You’ll find Assembly code in the BIOS, device drivers, embedded devices (such as smart sensors or medical equipment), and even in performance-critical parts of modern software.
It also plays a role in reverse engineering, where experts study how a compiled program works by looking at its Assembly instructions. Going from a high-level language down to Assembly is easy; going back up is not.
Unfortunately, the same power that makes Assembly useful can also make it attractive to malware developers — because Assembly can directly interact with hardware in ways higher-level languages cannot.
💡 Real-World Scenarios
Scenario 1: Giving Very Specific Instructions
Imagine telling someone:
- “Clean the room.” → This is like Python or Java.
- “Pick up the blue sock. Put it in the basket. Move the basket to the corner…” → This is Assembly.
Assembly breaks down tasks into tiny, exact steps, just like this.
Scenario 2: When Your Phone First Turns On
Before your phone loads Android or iOS, the processor runs tiny instructions stored deep inside the hardware. These instructions — things like checking memory, running tests, and starting the system — are written in Assembly because they must run directly on the hardware.
Scenario 3: Old Game Consoles & Small Devices
Classic game consoles and modern small devices (like microwaves, watches, or sensors) have very limited power. Assembly helps squeeze out every bit of performance, which is why it’s still used in such systems today.
Understanding Notational Systems 🔢
At the deepest level, a computer understands only one notational system: binary — the world of 1’s and 0’s. Everything your computer does — playing a game, loading a website, watching a video, or chatting with a friend — ultimately becomes nothing more than extremely long sequences of 0s and 1s. It’s amazing how two little digits power everything we see on our screens.
A simple way to understand this is to think of a light switch. Ignoring fancy dimmable bulbs for a moment, a traditional switch has only two states:
- 1 = ON
- 0 = OFF
That’s binary — also called base-2, because it uses only two symbols.
Humans, on the other hand, are most comfortable with the base-10, or decimal, system, which uses the digits 0 through 9. When we go beyond 9, we add a new digit in front and reset the rightmost digit to 0 — for example, 9 → 10. If you’d like help understanding how binary converts to decimal, check out the article on the topic 👉 — Binary to Decimal
In programming, another commonly used notation system is hexadecimal (base-16). Hexadecimal uses sixteen possible symbols: 0–9 and A–F, where A = 10, B = 11, and so on up to F = 15. If you’d like help understanding how binary converts to Hexadecimal, check out the article on the topic 👉 Binary to HexaDecimal
Binary, decimal, and hexadecimal work great for numbers, but computers also need to represent letters, symbols, and special characters. That’s where character encoding systems come in. The first widely used standard was ASCII, which assigns a number to each letter, digit, and symbol. You’ve also written an article on converting binary to text using ASCII so that readers can explore that for more detail.
However, ASCII had a big limitation — it only included enough characters for the English alphabet. As computers spread worldwide, that wasn’t enough.
To solve this, a more inclusive system was needed, and that led to Unicode. Today, Unicode is the global standard. It supports:
- 136,755 characters
- across 139 languages and writing systems
Unicode comes in different formats:
- UTF-8 uses 8 bits and is identical to ASCII for basic characters.
- UTF-16 uses 16 bits, allowing up to 65,536 characters, and covers what’s known as the Basic Multilingual Plane. UTF-16 is now one of the most common encoding standards in modern software
If you’d like help understanding how binary converts to Text, check out the article on the topic 👉Binary to Text
Exercise 🧪 : Converting Between Decimal and Other Numbering Systems
- In Windows 11, open the Calculator app. Type calc into the Windows search bar and press Enter.
- Switch to Programmer mode.
- Click the Calculator menu button (upper-left corner) and choose Programmer.
- Notice the mark next to Dec, indicating the current view is set to decimal.
- Enter the number 61.
- The calculator will show the hexadecimal (HEX), decimal (DEC), octal (OCT), and binary (BIN) versions of the number.
- Now enter the number 7391.
- Observe that in binary, 2 bytes (16 bits) of data are shown, and four hexadecimal characters appear.
- Try a few more numbers.
- Experiment with your birth year or another meaningful number to see what it looks like in binary or hex.
- Close the calculator when you’re done.
Working With Assembly 🛠️
Coding in Assembly is not easy. To write real programs in it, you need to know:
- the exact type of processor you’re using,
- how memory is organized,
- and how the processor behaves in different environments.
So yes — Assembly is powerful, but also challenging. To make this easier to understand, let’s walk through a very simple example and break it down step by step.
Example: Moving a Number Into a CPU Register 🔢
Computers only understand binary — 1s and 0s. Let’s pretend you have a 32-bit Intel processor, and you want to tell it: 👉 “Put the number 42 into a memory register called AL.” The computer doesn’t understand English, so it needs this instruction in binary. Here’s how the processor expects the instruction:
- The command for “move data”. In binary, this is written as: 10110
- The code for the register AL. AL is a small part of a bigger register called AX. In binary, AL is represented as: 000
- The number we want to move (42): 42 in binary is: 0010 1010
- Now we put all the pieces together: Binary instruction: 10110 000 0010 1010
This is only to understand that it is made of three parts.
In simple English, this means:
- 10110 → Move data
- 000 → Into register AL
- 0010 1010 → The number 42
That’s it.
Why Assembly Developers Prefer Not Using Raw Binary 🤯
Even though the binary instruction works, it’s extremely difficult to read or remember. So programmers convert the instruction into hexadecimal to make it shorter.
Using binary → hex conversion:
- 1011 0000 becomes B0
- 0010 1010 becomes 2A
So the instruction becomes: Hex version: B0 2A, which means: 👉 “Move the number 42 into AL.”
Better than binary, but still not easy to remember.
How Assembly Became Easier: Mnemonics ✍️
To make Assembly readable by humans, programmers created mnemonics. Mnemonics are short words that represent common commands. Example:
- MOV = Move
- AL = The AL register
- 2Ah = The number 42 in hexadecimal (the “h” means hex)
So instead of writing binary or hex, you can simply write:
Assembly instruction: MOV AL, 2Ah
That’s why using the mnemonic version is much easier. It reads almost like English: MOVE the number 42 into AL. This already makes Assembly much more approachable.
Another thing that helps is the use of comments. In Assembly, anything written after a semicolon ( ; ) is a comment. The processor completely ignores it, but humans rely on it to understand what the code is trying to do.
Comments turn confusing code into something readable. Even if you didn’t write the original code, a good comment lets you look at it and say: “Ohhh… so that’s what the programmer meant!”. Just like other languages, an Assembly line usually includes:
- Instructions – what to do
- Directives – special guidance for the assembler
- Data – information the program needs
- Comments – human-friendly explanations
The syntax changes between languages, but this structure is common everywhere.
A Real-World Example to Make This Easier 🌍
Imagine you walk into a kitchen and want someone to make tea. You could communicate this in three different ways — just like binary, hex, and Assembly mnemonics.
1️⃣ Binary (the computer’s true language)
Like giving instructions step by step, down to the tiniest motion:
- “Move your hand 4 inches to the right.”
- “Rotate your wrist 10 degrees.”
- “Grip the cup with exactly 12 newtons of force.”
This is how the CPU sees instructions — extremely precise, but unreadable to humans.
2️⃣ Hexadecimal (a shorter version of those steps)
Same instructions, but more compact:
- “Command B0 for picking cup.”
- “Command 2A for pouring water.”
Still low-level, still not very human-friendly — but shorter.
3️⃣ Assembly Mnemonics (human-friendly low-level instructions)
PICK CUP
POUR WATER
ADD TEA
This is what Assembly mnemonics do: They turn confusing machine instructions into short words like MOV, ADD, JMP, PUSH, etc. Now it becomes something we actually understand:
✔️ Write a program that prints “Hello, World!”
Almost every programming course begins with the same first assignment: Every language does it differently — and Assembly’s version is famously low-level but fun to see.
📟 “Hello, World!” in Assembly Language
section .text
global _start ; must be declared for linker (ld)
_start:
mov edx, len ; message length
mov ecx, msg ; message to write
mov ebx, 1 ; file descriptor (stdout)
mov eax, 4 ; system call (sys_write)
int 0x80 ; call kernel
section .data
msg db 'Hello, world!', 0xa ; the message + newline
len equ $ - msg ; length of the stringWhen this program is assembled and executed, the output will be: Hello, world!
📝 Note
Assembly is the lowest-level programming language possible. It sits just one step above raw machine code (1s and 0s) and is the closest a programmer can get to giving instructions directly to the processor. That’s why Assembly is powerful — but also why it can be challenging to learn.
Wrapping Up 🧭
Assembly Language may look intimidating at first, but understanding it gives you a whole new appreciation for how computers really work. It’s the closest you can get to the processor—one tiny instruction at a time—and it forms the foundation on which all modern software is built. You don’t need to master Assembly to be a great programmer, but knowing what’s happening “under the hood” makes every higher-level language easier to understand.
In the next article, we’ll step away from low-level coding and explore the languages most developers use today, as well as the most common types of programming languages in modern software development. 👉 Programming Languages