OS: Build & Compile Aplikasi Open Source

Dari Source Code ke Binary di Berbagai Sistem Operasi

Posisi Bab dalam Alur Sistem Operasi Setelah mahasiswa:

• Menginstal dan mengelola Ubuntu Server 24.04
• Meng-compile kernel Linux
• Membangun OpenWRT x86
• Membangun Android x86 dari source

maka langkah logis berikutnya adalah membangun aplikasi open source di atas sistem operasi tersebut. Bab ini menegaskan satu prinsip penting:

Sistem operasi bukan tujuan akhir — ia adalah platform eksekusi hasil kompilasi.

Dengan kata lain, nilai praktis OS baru terasa ketika mahasiswa mampu menghasilkan program yang berjalan native di OS tersebut.

Konsep Dasar Build & Compile dalam Perspektif OS

Secara akademik, build process adalah jembatan antara:

Source code (user space)

dan

Executable binary (berinteraksi dengan kernel)

Tahapan umum:

• Preprocessing
• Compilation
• Linking
• Execution

Setiap tahap berinteraksi langsung atau tidak langsung dengan kernel:

• Compiler → process scheduling
• Linker → filesystem & loader
• Binary → system call ke kernel

Insight OS:

Ketika Anda meng-compile aplikasi, Anda sedang melatih kernel menangani workload nyata.

Build Aplikasi Open Source di Ubuntu 24.04

Ubuntu sebagai Build Platform Utama

Ubuntu 24.04 dipilih sebagai platform build utama karena:

• Toolchain lengkap (gcc, make, cmake)
• Library stabil
• Lingkungan developer-friendly
• Basis untuk OpenWRT & Android build

Ubuntu berfungsi sebagai “factory OS” dalam keseluruhan ekosistem lab.

Contoh Build Aplikasi C Sederhana (Native Linux)

Langkah 1 — Buat Source Code

// hello.c
#include <stdio.h>

int main() {
    printf("Hello, Open Source OS World!\n");
    return 0;
}

Langkah 2 — Compile

gcc hello.c -o hello

Langkah 3 — Jalankan

./hello

Observasi OS:

• gcc adalah user-space compiler
• Binary hello dieksekusi kernel via ELF loader
• printf() memanggil system call ke kernel

Build dengan Makefile

CC=gcc
CFLAGS=-Wall

all:
	$(CC) $(CFLAGS) hello.c -o hello

make

Makna akademik:

Makefile merepresentasikan otomasi build—konsep penting di OS skala besar.

Build Aplikasi Open Source di OpenWRT

Filosofi Build di OpenWRT

Berbeda dengan Ubuntu, OpenWRT:

• Resource terbatas
• Fokus embedded
• Menggunakan cross-compilation

Konsep penting:

Aplikasi OpenWRT dibangun di host (Ubuntu), dijalankan di target (OpenWRT).

Menggunakan OpenWRT Build System

Masuk ke direktori source OpenWRT:

cd ~/openwrt

Update & install feed:

./scripts/feeds update -a
./scripts/feeds install -a

Contoh Package Sederhana OpenWRT

Struktur package:

package/hello-openwrt/
 ├── Makefile
 └── src/hello.c

Source Code

#include <stdio.h>

int main() {
    printf("Hello from OpenWRT!\n");
    return 0;
}

Makefile OpenWRT (ringkas)

include $(TOPDIR)/rules.mk

PKG_NAME:=hello-openwrt
PKG_VERSION:=1.0

include $(INCLUDE_DIR)/package.mk

define Package/hello-openwrt
  SECTION:=utils
  CATEGORY:=Utilities
  TITLE:=Hello OpenWRT
endef

define Build/Compile
	$(TARGET_CC) $(TARGET_CFLAGS) \
		-o $(PKG_BUILD_DIR)/hello \
		$(PKG_BUILD_DIR)/hello.c
endef

define Package/hello-openwrt/install
	$(INSTALL_DIR) $(1)/usr/bin
	$(INSTALL_BIN) $(PKG_BUILD_DIR)/hello $(1)/usr/bin/
endef

$(eval $(call BuildPackage,hello-openwrt))

Insight OS:

Di sini mahasiswa benar-benar berhadapan dengan cross-toolchain dan filesystem target.

Build Aplikasi Open Source di Android

Android sebagai Platform Build

Android bukan Linux desktop biasa:

• Menggunakan Bionic libc
• Tidak semua syscall tersedia
• Build menggunakan Android NDK

Contoh Build Native App Android (NDK)

Source Code (hello.c)

#include <stdio.h>

int main() {
    printf("Hello from Android native app!\n");
    return 0;
}

Compile dengan NDK (di Ubuntu)

$ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64/bin/clang \
  --target=x86_64-linux-android21 \
  hello.c -o hello-android

Deploy ke Android x86:

adb push hello-android /data/local/tmp/
adb shell chmod +x /data/local/tmp/hello-android
adb shell /data/local/tmp/hello-android

Observasi penting:

Binary Android tetap ELF Linux, tetapi menggunakan runtime & libc berbeda.

Konsep Cross-Compiling

Definisi Akademik

Cross-compiling adalah proses:

• Membangun aplikasi di satu OS/arsitektur untuk dijalankan di OS/arsitektur lain

Contoh:

• Build di Ubuntu x86_64
• Target: OpenWRT (MIPS/ARM)
• Target: Android x86/ARM

Komponen Cross-Compilation

• Host → Ubuntu 24.04
• Target → OpenWRT / Android
• Cross-compiler
  • Sysroot
  • Target libc

Kesalahan umum mahasiswa:

• Mengira compile = copy-paste binary.
• Padahal ABI & libc menentukan segalanya.

Perbandingan Singkat

Platform	Compiler	Libc
Ubuntu	gcc	glibc
OpenWRT	target-gcc	musl
Android	clang	bionic

Insight OS:

Kernel boleh sama, user space menentukan kompatibilitas aplikasi.

Mini Eksperimen (Integratif & Menantang)

Beberapa tantangan opsional:

• Build aplikasi yang sama di Ubuntu, OpenWRT, dan Android
• Bandingkan ukuran binary
• Bandingkan syscall yang tersedia
• Jalankan strace (Ubuntu) vs keterbatasan Android

Mahasiswa akan melihat langsung dampak desain OS terhadap aplikasi.

Refleksi Akademik (OBE-Oriented)

Setelah bab ini, mahasiswa mampu:

• Menjelaskan proses build aplikasi dari perspektif OS
• Membangun aplikasi open source di berbagai OS
• Memahami cross-compiling secara konseptual & praktis
• Mengaitkan toolchain dengan kernel & user space
• Berpikir sebagai system integrator, bukan sekadar programmer

Penutup

Bab ini menegaskan bahwa:

Kekuatan sistem operasi terletak pada kemampuannya menjadi platform build & eksekusi aplikasi. Dengan menyelesaikan bab ini, mahasiswa tidak hanya:

• • Mengerti OS
  • Membangun OS

tetapi juga memanfaatkan OS sebagai mesin produksi software lintas platform.

Selamat — Anda kini memahami sistem operasi dari kernel hingga aplikasi.

Pranala Menarik

• Sistem operasi