#cs#hardware#cpu#arm#x86
ARM vs x86: The Philosophy of Architecture
Why does MacBook battery last long? Should I use AWS Graviton? A deep dive into the philosophy of CISC (Complex) vs RISC (Simple) architectures.
February 12, 2025
Codemapo
Why does MacBook battery last long? Should I use AWS Graviton? A deep dive into the philosophy of CISC (Complex) vs RISC (Simple) architectures.
The gold mine of AI era, NVIDIA GPUs. Why do we run AI on gaming graphics cards? Learn the difference between workers (CUDA) and matrix geniuses (Tensor Cores).
Bought a fast SSD but it's still slow? One-lane country road (SATA) vs 16-lane highway (NVMe).
LP records vs USB drives. Why physically spinning disks are inherently slow, and how SSDs made servers 100x faster.
I thought the motherboard was just a board to plug things into. Then I learned what a chipset does.
When I first got my M1 MacBook, I was shocked. My old Intel MacBook sounded like a jet engine taking off, and I couldn't survive an hour at a cafe without a charger. Compiling code would spin the fans to max RPM and heat up my desk. Plus, the battery died in 2 hours.
But the M1 was different. After a full day of work, it still had 60% battery left, and the fans never spun once. Even running 10 heavy Docker containers - silent.
I couldn't just accept "Apple makes good chips." I needed to know why. It turns out, it's about Architecture. One is x86, and the other is ARM. But what does that mean?
Early Google search results said:
"x86 is CISC-based, ARM is RISC-based."
Me: "?????"
"CISC stands for Complex Instruction Set Computer, which processes complex instructions in one go."
Me: "Okay but why does that matter for battery life?"
Too theoretical. I couldn't relate. Then I stumbled upon one analogy that clicked. "The Chef and The Line Cooks."
The best analogy I found was a "Kitchen".
Chips from Intel and AMD use x86, which is based on CISC (Complex Instruction Set Computer). As the name suggests, it uses 'Complex Instructions'.
Imagine a "Michelin 3-Star Genius Chef". This chef is incredibly smart. You give one command: "Make Sushi!" (Complex Instruction). The chef alone:
The command is simple. "Make Sushi" is just one line. (Short code length).
But there's a downside. Because the chef is so smart and does so much, their brain gets hot and they need a lot of food (electricity). They are amazing at complex dishes (High-performance computing), but it feels overkill for simple tasks like making a sandwich.
On the other hand, ARM uses RISC (Reduced Instruction Set Computer). It uses 'Reduced Instructions'.
Imagine an "Army of Fast Line Cooks". They don't understand "Make Sushi". They only understand very simple commands:
The instructions get longer. (Longer code length). But because each action is so simple, they execute them at lightning speed. And since they don't have to think hard, they use much less electricity.
After reading this analogy, my M1 MacBook started making sense.
"Oh, that's why M1 is quiet and cool."
But I had a question. "Isn't it better to have one complex instruction? Why split it into multiple simple ones?"
The answer lies in The Shift in Eras.
In the past, RAM was extremely expensive. In the 1980s, having a computer at home meant you were rich, and memory was measured in KB. So keeping the program size (code length) small was the #1 priority.
That's why CISC (x86) ruled. "Make Sushi" taking up only one line was efficient. This was Intel's golden age.
Developers back then thought:
"Short code = Memory savings = Best!"
But now, Memory is cheap. My laptop has 16GB RAM, and apps using hundreds of MB don't matter. Long code doesn't matter.
Instead, "Battery Efficiency" and "Heat Management" are king. It's the smartphone era.
That's why the small, cool, energy-efficient RISC (ARM) is taking over.
It was when I ran servers on AWS. Same performance instance, but:
20% difference. That's $120/year.
"Oh, this actually costs real money."
This theory became real for me when choosing an AWS instance.
I was torn between t3.medium (x86) and t4g.medium (ARM, Graviton).
"ARM? Doesn't that have compatibility issues?" "What if my x86 code doesn't run on ARM?"
Online opinions were split:
My blog backend was Next.js. I created a Dockerfile and built two versions:
# x86 build
docker build --platform linux/amd64 -t blog:x86 .
# ARM build
docker build --platform linux/arm64 -t blog:arm .
Results:
sharp library (image processing).But updating sharp to the latest version fixed it.
High-level languages like Node.js or Python have excellent ARM support.
After deploying to AWS Graviton (t4g.medium):
| Metric | x86 (t3.medium) | ARM (t4g.medium) |
|---|---|---|
| Price | $50/month | $40/month (20% cheaper) |
| Response Time | Avg 120ms | Avg 100ms (Faster!) |
| CPU Usage | Avg 30% | Avg 25% |
| Memory | 4GB | 4GB (Same) |
It was even faster. Used less CPU for the same requests.
"Why isn't everyone using ARM?"
Of course, ARM isn't always the answer.
ARM is Difficult When:What I learned from migrating x86 → ARM.
# Mac M1/M2 users are ARM by default
docker build --platform linux/arm64 -t myapp:arm .
docker run myapp:arm
# Intel Mac / Windows users can emulate with QEMU
docker buildx build --platform linux/arm64 -t myapp:arm .
If it runs locally, 99% chance it runs on actual ARM servers.
To support both x86 and ARM:
docker buildx build --platform linux/amd64,linux/arm64 -t myapp:latest .
One image, two architectures. No redeployment needed when switching AWS ECS/Fargate instance types.
Don't switch all servers at once.
Smartphones are 100% ARM. iPhone (Apple A-series), Android (Qualcomm Snapdragon) - all ARM architecture. No x86 smartphones exist.
AWS, Google Cloud, Azure all offer ARM instances.
As of 2025, about 15% of cloud workloads run on ARM. Some predict 50% by 2030.
High-performance gaming PCs still run Intel i9, AMD Ryzen. Windows games are x86-based, so this won't change soon.
But if Apple M-series catches up in gaming performance... who knows.
| Type | CISC (x86) | RISC (ARM) |
|---|---|---|
| Analogy | Genius Chef | Fast Assembly Line |
| Pros | Complex tasks in one go | Low power, Low heat |
| Examples | Intel i9, AMD Ryzen | Apple M1/M2, AWS Graviton |
| Takeaway | "Heavy lifting" | "Efficient & Long-lasting" |
When I first bought my M1 MacBook, I just thought "Apple makes good chips." But digging deeper, it was about architectural philosophy.
In the era of mobile and cloud, the light and efficient 'assembly line' is more welcomed than the heavy and hot 'genius'.
High-end gaming desktops still run x86, but even that might change someday.
As I write this, my M1 MacBook is at 80% battery. The fans remain silent.