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