Belajar Math - Number Systems untuk Komputer

#Pendahuluan

Setelah di episode 1 kita memahami bagaimana matematika muncul di berbagai aspek pemrograman, pada episode ini kita mulai dari fondasi paling dasar: number systems. Komputer tidak memahami angka desimal — mereka beroperasi dalam biner (0 dan 1). Sebagai programmer, kalian perlu lancar berpindah antara desimal, biner, oktal, dan heksadesimal, serta memahami bagaimana representasi angka ini muncul dalam kehidupan nyata: warna hex pada CSS, bitwise operators, IP address, dan encoding teks.

Mengapa ini penting? Karena ketika kalian melihat #FF5733 di CSS, itu bukan teks acak — itu representasi heksadesimal dari warna. Ketika kalian membaca permission chmod 755, itu oktal. Ketika kalian debugging network packet, kalian melihat hex dump. Memahami number systems membuat kalian bisa "membaca" komputer dengan lebih jelas.

#Desimal ke Biner dan Sebaliknya

#Konsep Dasar

Sistem desimal (base-10) menggunakan 10 digit (0-9), sedangkan biner (base-2) hanya menggunakan 2 digit (0 dan 1). Setiap posisi digit dalam biner merepresentasikan pangkat 2:

Biner 1101 = 1×2³ + 1×2² + 0×2¹ + 1×2⁰
           = 8 + 4 + 0 + 1
           = 13 (desimal)

#Konversi Manual: Desimal ke Biner

Metode "divide by 2" — bagi angka desimal dengan 2 secara berulang, catatan sisa:

13 ÷ 2 = 6 sisa 1
 6 ÷ 2 = 3 sisa 0
 3 ÷ 2 = 1 sisa 1
 1 ÷ 2 = 0 sisa 1
 
Baca sisa dari bawah ke atas: 1101

#Konversi Manual: Biner ke Desimal

Kalikan setiap digit dengan pangkat 2 sesuai posisinya, lalu jumlahkan:

1101₂ = 1×8 + 1×4 + 0×2 + 1×1 = 13₁₀

#Verifikasi dengan Python

Konversi desimal-biner dengan Python

# Desimal ke biner
n = 13
print(f"bin({n}) = {bin(n)}")          # 0b1101
 
# Biner ke desimal
print(f"int('1101', 2) = {int('1101', 2)}")  # 13
 
# Konversi manual untuk verifikasi
def desimal_ke_biner(n: int) -> str:
    if n == 0:
        return "0"
    result = []
    while n > 0:
        result.append(str(n % 2))
        n //= 2
    return "".join(reversed(result))
 
print(f"Manual: {desimal_ke_biner(13)}")  # 1101

#Oktal dan Heksadesimal

#Oktal (Base-8)

Oktal menggunakan 8 digit (0-7). Setiap posisi adalah pangkat 8. Oktal jarang dipakai langsung, tetapi muncul di permission Unix:

chmod 755 → 7=111, 5=101, 5=101 (biner)
Artinya: owner=rwx, group=r-x, other=r-x

#Heksadesimal (Base-16)

Heksadesimal menggunakan 16 simbol: 0-9 dan A-F (A=10, B=11, ..., F=15). Setiap posisi adalah pangkat 16. Heksadesimal populer karena 1 digit hex = tepat 4 bit — hubungan langsung ke biner:

Hex  → Biner  → Desimal
0    → 0000   → 0
1    → 0001   → 1
A    → 1010   → 10
F    → 1111   → 15
FF   → 11111111 → 255

#Verifikasi dengan Python

Konversi antar basis dengan Python

n = 255
 
print(f"Desimal: {n}")
print(f"Biner:   {bin(n)}")    # 0b11111111
print(f"Oktal:   {oct(n)}")    # 0o377
print(f"Hex:     {hex(n)}")    # 0xff
 
# Balik: dari hex ke desimal
print(f"int('FF', 16) = {int('FF', 16)}")    # 255
print(f"int('377', 8) = {int('377', 8)}")    # 255
print(f"int('11111111', 2) = {int('11111111', 2)}")  # 255

#Aplikasi Nyata

#Warna Hex di CSS

Setiap warna RGB direpresentasikan sebagai 3 pasang hex: #RRGGBB. Setiap pair bernilai 0-255 (FF):

Decode warna hex

def hex_ke_rgb(hex_color: str) -> tuple:
    hex_color = hex_color.lstrip("#")
    r = int(hex_color[0:2], 16)
    g = int(hex_color[2:4], 16)
    b = int(hex_color[4:6], 16)
    return (r, g, b)
 
print(hex_ke_rgb("#FF5733"))  # (255, 87, 51) — warna oranye
print(hex_ke_rgb("#000000"))  # (0, 0, 0) — hitam
print(hex_ke_rgb("#FFFFFF"))  # (255, 255, 255) — putih

#Bitwise Operators

Bitwise operators bekerja pada level bit individual — AND (&), OR (|), XOR (^), NOT (~), shift (<<, >>):

Bitwise operators

a = 0b1100  # 12
b = 0b1010  # 10
 
print(f"AND: {bin(a & b)}")    # 0b1000 (8)
print(f"OR:  {bin(a | b)}")    # 0b1110 (14)
print(f"XOR: {bin(a ^ b)}")    # 0b0110 (6)
print(f"NOT: {bin(~a & 0xF)}") # 0b0011 (3, 4-bit mask)
print(f"Left shift:  {bin(1 << 3)}")   # 0b1000 (8)
print(f"Right shift: {bin(16 >> 2)}")  # 0b100 (4)

Bitwise AND sering dipakai untuk masking — mengecek apakah bit tertentu aktif tanpa mempengaruhi bit lain.

#IP Address

IP address adalah 4 oktet yang masing-masing 8 bit (0-255). Representasi desimal dotted (192.168.1.1) sebenarnya adalah 32-bit biner:

IP address dan biner

def ip_ke_biner(ip: str) -> str:
    octets = ip.split(".")
    return ".".join(f"{int(o):08b}" for o in octets)
 
def biner_ke_ip(biner: str) -> str:
    octets = biner.split(".")
    return ".".join(str(int(o, 2)) for o in octets)
 
print(ip_ke_biner("192.168.1.1"))
# 11000000.10101000.00000001.00000001
 
print(biner_ke_ip("11000000.10101000.00000001.00000001"))
# 192.168.1.1

#Two's Complement (Bilangan Negatif)

Komputer menyimpan bilangan negatif menggunakan two's complement: balik semua bit, lalu tambah 1. Ini memungkinkan operasi penjumlahan dan pengurangan menggunakan sirkuit yang sama.

Two's complement 8-bit

def to_twos_complement(n: int, bits: int = 8) -> str:
    if n >= 0:
        return format(n, f"0{bits}b")
    else:
        return format((1 << bits) + n, f"0{bits}b")
 
print(f"+5:  {to_twos_complement(5)}")    # 00000101
print(f"-5:  {to_twos_complement(-5)}")   # 11111011
print(f"+127: {to_twos_complement(127)}") # 01111111
print(f"-128: {to_twos_complement(-128)}")# 10000000

Range untuk 8-bit signed: -128 sampai +127. Jika melebihi batas ini, terjadi integer overflow — bug umum yang perlu dipahami.

#UTF-8 Encoding

UTF-8 menggunakan 1-4 byte untuk merepresentasikan karakter Unicode. Karakter ASCII (A-Z, a-z, 0-9) cukup 1 byte, sedangkan karakter non-Latin membutuhkan lebih banyak:

UTF-8 byte representation

chars = ["A", "é", "中", "😀"]
 
for ch in chars:
    encoded = ch.encode("utf-8")
    print(f"'{ch}' → {encoded.hex()} ({len(encoded)} byte)")

Memahami bagaimana karakter direpresentasikan dalam byte membantu debugging encoding issues — masalah umum yang sering memakan waktu berjam-jam jika tidak dipahami.

#Bit Mask untuk Permission

Dalam Unix, permission direpresentasikan sebagai 3 bit per kategori (owner/group/other): read=4 (100), write=2 (010), execute=1 (001). Bitwise OR menggabungkan, bitwise AND mengecek:

Permission flags dengan bitwise

READ = 0b100    # 4
WRITE = 0b010   # 2
EXEC = 0b001    # 1
 
# Buat permission rwxr-xr-x
owner_perm = READ | WRITE | EXEC   # 111 = 7
group_perm = READ | EXEC           # 101 = 5
other_perm = READ | EXEC           # 101 = 5
 
permission = (owner_perm << 6) | (group_perm << 3) | other_perm
print(f"chmod {oct(permission)}")  # 0o755
 
# Cek apakah owner punya write permission
has_write = bool(permission & (WRITE << 6))
print(f"Owner can write: {has_write}")  # True

#Penutup

Inti yang harus dibawa pulang:

• Komputer beroperasi dalam biner (base-2); programmer perlu berpindah antara desimal, biner, oktal, dan heksadesimal.
• Heksadesimal erat dengan biner: 1 digit hex = 4 bit — membuatnya praktis untuk merepresentasikan warna (#FF5733), memory addresses, dan hex dumps.
• Bitwise operators (&, |, ^, ~, <<, >>) bekerja pada level bit; digunakan untuk masking, permission flags, dan efisiensi komputasi.
• Two's complement adalah cara komputer menyimpan bilangan negatif — penting untuk memahami integer overflow.
• UTF-8 merepresentasikan karakter Unicode dalam 1-4 byte — memahami encoding menghindari bug encoding yang memakan waktu.

Di episode 3 selanjutnya kita akan mempelajari arithmetic dan aljabar dasar — operator precedence, pecahan, persentase, akar kuadrat, persamaan linear, dan bagaimana konsep ini muncul dalam pricing logic, diskon, dan grading algorithms. Pastikan kalian sudah nyaman dengan konversi antar basis sebelum melanjutkan!