Perbandingan Self-Learning Bare Metal OS vs Kurikulum MIT 6.1810

Filosofi Pembelajaran: Dua Pendekatan yang Saling Melengkapi

Pendekatan MIT 6.1810 (Top-Down)

MIT mengajarkan sistem operasi dengan memulai dari abstraksi tinggi ke implementasi rendah. Mahasiswa mempelajari konsep teoritis seperti virtual memory, process scheduling, dan file systems terlebih dahulu, kemudian mengimplementasikannya dalam lingkungan yang sudah terstruktur (xv6, sistem operasi pendidikan berbasis Unix).

Kelebihan:

• Mahasiswa memahami “mengapa” sebelum “bagaimana”
• Infrastruktur debugging sudah tersedia
• Fokus pada algoritma dan struktur data OS
• Lingkungan pembelajaran yang terkontrol

Keterbatasan:

• Banyak detail hardware diabstraksi
• Tidak merasakan “pain point” sebenarnya dari bare metal
• Kurang exposure terhadap arsitektur processor spesifik

Pendekatan Bare Metal Self-Learning (Bottom-Up)

Membuat OS dari nol tanpa framework memaksa Anda memulai dari silicon mentah ke abstraksi tinggi. Anda menulis setiap byte yang dieksekusi CPU, mulai dari instruksi pertama setelah power-on.

Kelebihan:

• Pemahaman mendalam tentang hardware-software interface
• Apresiasi terhadap kompleksitas abstraksi yang sering dianggap “gratis”
• Debugging skill yang superior (karena tidak ada safety net)
• Portofolio yang sangat mengesankan untuk rekruter

Keterbatasan:

• Kurva pembelajaran sangat curam
• Mudah terjebak di detail teknis dan melupakan big picture
• Butuh waktu sangat lama untuk sampai ke topik lanjutan

Pemetaan Detail: Praktikum Bare Metal vs Kurikulum MIT

Phase 1: Initialization & Hardware Bring-Up

Pelajaran Kunci:

• Bare metal mengajarkan bahwa “printf tidak gratis”—Anda harus membangun seluruh stack komunikasi dari register GPIO
• MIT mengajarkan abstraksi: mengapa kita perlu memisahkan device driver dari kernel core

Sintesis: Setelah membuat UART driver sendiri, kembali ke MIT coursework dan Anda akan sangat menghargai desain interface seperti read() dan write().

Phase 2: Interrupts & Exception Handling

Contoh Konkret:

Bare Metal (ARM64):

.global vector_table_el1
.balign 0x800
vector_table_el1:
    // Current EL with SP0
    .balign 0x80
    b sync_invalid_el1t
    .balign 0x80
    b irq_handler_el1t
    // ... 16 total entries

MIT xv6:

// Trap handling sudah diatur, mahasiswa hanya perlu:
void
trap(struct trapframe *tf)
{
  if(tf->trapno == T_SYSCALL) {
    // Handle syscall
  }
}

Pembelajaran:

• Bare metal: “Bagaimana CPU tahu harus jump ke mana saat interrupt?”
• MIT: “Bagaimana kita mendesain trap handling yang aman dan efisien?”

Phase 3: Memory Management

Diagram Perbedaan Pendekatan:

MIT Approach:
[Kernel Virtual Address] → walkpgdir() → [Physical Address]
                ↓
         (implementasi Anda)

Bare Metal Approach:
[Virtual Address] → Level 0 Table → Level 1 Table → Level 2 Table → Level 3 Table → [Physical Page]
         ↓              ↓               ↓               ↓               ↓
    (Anda buat)    (Anda buat)     (Anda buat)     (Anda buat)     (Anda validasi)

Tantangan Unik Bare Metal:

• Cache Coherency: Setelah menulis page table, Anda harus DSB, ISB, dan invalidate instruction cache—jika lupa, CPU akan execute kode lama
• Translation Granule: ARM mendukung 4KB, 16KB, 64KB pages—Anda harus memilih dan configure TCR_EL1
• ASID (Address Space ID): Optimasi untuk avoid TLB flush saat context switch

MIT Focus:

• Algoritma: bagaimana mencegah race condition saat dua process allocate page bersamaan?
• Abstraksi: desain API yang clean untuk user space memory management

Phase 4: Process & Scheduling

Code Comparison:

Bare Metal Context Switch (ARM64):

context_switch:
    // Save current context
    stp x0, x1, [x0, #0]
    stp x2, x3, [x0, #16]
    // ... save all 31 registers + SP + PC
    
    // Restore next context
    ldp x0, x1, [x1, #0]
    ldp x2, x3, [x1, #16]
    // ... restore all registers
    ret

MIT xv6:

// Mahasiswa hanya perlu mengelola scheduler logic
void
scheduler(void)
{
  for(;;) {
    for(p = proc; p < &proc[NPROC]; p++) {
      if(p->state == RUNNABLE) {
        swtch(&cpu->context, &p->context);
      }
    }
  }
}

Pelajaran:

• Bare metal: “Register x30 (link register) harus disimpan, atau function call setelah context switch akan crash”
• MIT: “Bagaimana menghindari priority inversion dalam scheduler?”

Phase 5: System Calls & User Programs

Contoh User Program Comparison:

Bare Metal User Code:

// Tidak ada stdlib.h, harus syscall manual
void _start(void) {
    asm volatile(
        "mov x0, #1\n"           // stdout
        "adr x1, msg\n"          // buffer
        "mov x2, #13\n"          // length
        "mov x8, #64\n"          // syscall number (write)
        "svc #0\n"
        ::: "x0", "x1", "x2", "x8"
    );
    
    // Exit
    asm volatile("mov x8, #93\n svc #0");
}

const char msg[] = "Hello World!\n";

MIT xv6 User Code:

#include "user.h"

int main(void) {
    printf("Hello World!\n");
    exit(0);
}

Phase 6: File Systems

Tantangan Unik Bare Metal – SD Card:

1. Init: CMD0 → CMD8 → ACMD41 (loop sampai ready)
2. Set Block Size: CMD16
3. Read: CMD17 → wait data token → read 512 bytes → read CRC
4. Timeout handling: SD card bisa "hang" dan harus di-reset

MIT tidak mengajarkan ini karena fokus ke filesystem logic,
bukan hardware quirks.

Roadmap Sintesis: Menggabungkan Kedua Pendekatan

Untuk Self-Learner yang Ingin Setara MIT:

Tahap 1: Foundation (Bulan 1-2)

• Bare Metal: Boot ke UART “Hello World” di ARM dan x86
• Teori MIT: Baca Operating System: Three Easy Pieces – Chapter 4-6 (Processes)
• Lab Praktis: Implement context switch untuk dua “tasks” sederhana

Tahap 2: Memory Mastery (Bulan 3-4)

• Bare Metal: Aktifkan MMU, buat identity mapping untuk kernel
• Teori MIT: MIT 6.1810 Lecture Notes tentang Virtual Memory
• Lab Praktis: Implement malloc() sederhana dengan buddy allocator

Tahap 3: Interrupts & Scheduling (Bulan 5-6)

• Bare Metal: Timer interrupts + round-robin scheduler untuk 4 tasks
• Teori MIT: Pelajari CFS (Completely Fair Scheduler) dari Linux
• Lab Praktis: Tambahkan priority levels ke scheduler Anda

Tahap 4: User Space (Bulan 7-8)

• Bare Metal: Load ELF binary ke user mode, implement 5 syscalls dasar
• Teori MIT: xv6 book Chapter 2 (System Calls)
• Lab Praktis: Buat “shell” sederhana yang bisa fork/exec

Tahap 5: Persistence (Bulan 9-12)

• Bare Metal: SD card driver + FAT32 read-only filesystem
• Teori MIT: MIT 6.1810 Labs tentang file systems
• Lab Praktis: Implement write support + journaling sederhana

Keunggulan Kompetitif Self-Learning Bare Metal

1. Debugging Tanpa Crutches

Saat sistem hang di bare metal, Anda tidak punya:

• printf() (karena UART belum diinit)
• Debugger dengan symbols (karena tidak ada OS host)
• Stack traces (karena exception handler belum dibuat)

Solusi: Belajar menggunakan:

• JTAG debugger (OpenOCD + GDB)
• Logic analyzer untuk debug hardware timing
• LED blinking sebagai “print debugging” primitif

Skill ini membuat Anda unggul dalam embedded systems interview.

2. Apresiasi Terhadap Abstraksi

Setelah menghabiskan 200 lines assembly untuk timer interrupt, Anda akan sangat menghargai satu baris Python:

time.sleep(1)

Ini membuat Anda system thinker yang lebih baik di semua level stack.

3. Portofolio yang Memukau

Recruiter melihat:

• ❌ “Completed MIT 6.1810 labs” → Bagus, tapi banyak yang melakukan
• ✅ “Built bare metal OS for Raspberry Pi dan x86, runs on real hardware” → Sangat jarang

Kapan Memilih MIT-Style vs Bare Metal?

Pilih MIT-Style jika:

• Ingin cepat memahami algoritma dan struktur data OS
• Target: Software Engineering di perusahaan besar (Google, Meta)
• Waktu terbatas (1 semester)

Pilih Bare Metal jika:

• Ingin karir di embedded systems, firmware, atau kernel development
• Target: Perusahaan seperti ARM, Qualcomm, Tesla (Autopilot team)
• Siap investasi waktu 6-12 bulan
• Suka “suffers builds character” mindset

Gabungkan Keduanya jika:

• Ingin menjadi exceptional system programmer
• Target: Kernel maintainer Linux, BSD, atau sejenisnya
• Membuat konten edukasi berkualitas tinggi

Rekomendasi Resource

Untuk Bare Metal:

1. ARM:
   • ARM Architecture Reference Manual ARMv8 (official)
   • Raspberry Pi Bare Metal Programming (blog series)
   • Learning OS Development using Linux kernel and Raspberry Pi
2. x86:
   • Intel Software Developer Manual Volume 3 (Chapter 1-9)
   • OSDev Wiki (osdev.org)
   • Writing a Simple Operating System from Scratch (University of Birmingham)

Untuk Teori:

1. Operating Systems: Three Easy Pieces (OSTEP) – Free online
2. MIT 6.1810 Lecture Videos – YouTube
3. xv6 Commentary – Bagus untuk memahami design decisions

Untuk Debugging:

1. QEMU dengan -d int,cpu_reset untuk trace execution
2. OpenOCD + GDB untuk real hardware debugging
3. Ghidra/IDA Pro untuk reverse engineering bootloaders

Kesimpulan: Filosofi “T-Shaped Learning”

        [Deep Bare Metal Knowledge]
                    |
                    |  ← Vertical depth
                    |
    ════════════════════════════  ← Horizontal breadth (MIT curriculum)
    Processes | Memory | FS | Network

Ideal path:

1. Pilih satu platform (ARM atau x86) untuk dive deep sampai kernel berjalan
2. Paralel baca teori MIT untuk memahami “why” di balik setiap keputusan desain
3. Iterasi: Kembali ke bare metal code Anda dan refactor berdasarkan insight teoritis

Dengan cara ini, Anda mendapat:

• ✅ Depth: Pemahaman hardware-level yang superior
• ✅ Breadth: Pemahaman konseptual setara MIT grad student
• ✅ Portfolio: Project konkret yang bisa di-demo ke recruiter

Dalam 12 bulan, Anda bisa menjadi system programmer yang lebih well-rounded daripada 90% CS graduates.