# 🧩 Memahami Native Binding (C++) dan ABI Antara Node.js dan Bun

> “Menguasai JavaScript modern tidak hanya soal sintaks — tapi juga memahami jembatan antara JavaScript dan dunia native (C++).”

---

## 🧠 Pendahuluan

JavaScript lahir sebagai bahasa **interpreted** di browser, tetapi kini sudah berkembang pesat menjadi bahasa **server-side** dengan performa tinggi melalui platform seperti **Node.js** dan **Bun**.  
Di balik keajaiban performa library seperti TensorFlow.js, bcrypt, sharp, atau sqlite, ada satu komponen penting:  
➡️ **Native binding (C++)** yang menjembatani JavaScript dengan kode native (biasanya ditulis dalam C/C++).

---

## ⚙️ Apa Itu Native Binding?

**Native binding** adalah **lapisan penghubung (bridge)** antara runtime JavaScript (seperti Node.js atau Bun) dengan **kode C/C++ native**.

Bayangkan:

* Kode JavaScript adalah “otak” yang memerintah.
    
* Kode C++ adalah “otot” yang melakukan kerja berat seperti perhitungan numerik, GPU, enkripsi, dan sebagainya.
    
* Native binding adalah “saraf” yang menyambungkan keduanya.
    

Contoh sederhana:

```cpp
// addon.cc
#include <napi.h>

Napi::Number Add(const Napi::CallbackInfo& info) {
  double value = info[0].As<Napi::Number>().DoubleValue() +
                 info[1].As<Napi::Number>().DoubleValue();
  return Napi::Number::New(info.Env(), value);
}

Napi::Object Init(Napi::Env env, Napi::Object exports) {
  exports.Set("add", Napi::Function::New(env, Add));
  return exports;
}

NODE_API_MODULE(addon, Init)
```

Kemudian dipanggil dari JavaScript:

```js
const addon = require('./build/Release/addon.node');
console.log(addon.add(5, 7)); // Output: 12
```

File `.node` di sini adalah **binary hasil kompilasi C++** yang dipanggil langsung dari JavaScript.

---

## 🧱 Apa Itu ABI (Application Binary Interface)?

**ABI (Application Binary Interface)** adalah **aturan komunikasi di level mesin** antara program dan library yang dikompilasi.

Jika API adalah "perjanjian fungsi" di level kode sumber (misalnya `function add(a, b)`), maka:  
➡️ ABI adalah “perjanjian biner” — bagaimana fungsi itu disimpan di memori, bagaimana parameter dikirim, bagaimana hasil dikembalikan.

Perbedaan ABI menyebabkan library native **tidak bisa dijalankan** di runtime lain, walaupun bahasanya sama (misalnya Node.js vs Bun).

---

## 🧩 Hubungan Node.js dan ABI

Node.js menggunakan **Node-API (N-API)** sebagai standar binding antara JavaScript dan C++.

* Setiap versi Node.js punya **ABI version number** (misalnya `NODE_MODULE_VERSION=115` untuk Node 20).
    
* File `.node` yang dikompilasi hanya bisa dipakai di runtime dengan ABI yang sama.
    
* Contoh: addon `.node` untuk Node v16 belum tentu bisa dijalankan di Node v20 tanpa rebuild.
    

Kamu bisa cek ABI versi Node dengan:

```bash
node -p process.versions.modules
```

---

## ⚡ Bun dan Masalah ABI

Bun tidak memakai V8 seperti Node.js, tetapi **JavaScriptCore (JSC)** milik WebKit.  
Akibatnya, meskipun Bun mendukung sebagian besar API JavaScript modern, ABI-nya **tidak identik** dengan Node.js.

Namun, Bun punya **layer kompatibilitas Node ABI** agar bisa menjalankan sebagian besar native binding yang dibuat untuk Node, termasuk:

* `@tensorflow/tfjs-node`
    
* `sharp`
    
* `sqlite3`
    
* `bcrypt`
    

Kadang, library yang sangat bergantung pada ABI spesifik Node tetap perlu **rebuild ulang** atau **plugin adaptif** di Bun.

---

## 🧩 Bagaimana Bun Menangani Native Binding

Bun menyediakan dua mekanisme:

1. **Node Compatibility Layer**  
    Bun akan mencoba memuat file `.node` yang dikompilasi untuk Node ABI tertentu (biasanya bekerja untuk ABI modern seperti Node 18+).
    
2. **Bun Plugin System**  
    Developer dapat membangun **addon native khusus Bun** menggunakan API C++ Bun sendiri.  
    Ini lebih optimal karena langsung menggunakan **JavaScriptCore binding** tanpa perantara.
    

Contoh konfigurasi di `bunfig.toml`:

```toml
[native]
binding = true
```

---

## 🔄 Mengonversi Addon Node.js ke Bun

Jika kamu punya addon C++ dari Node.js, cara termudah untuk “mengonversi” ke Bun:

1. **Coba jalankan langsung** — Bun sering kompatibel dengan ABI Node.
    
    ```bash
    bun run index.ts
    ```
    
2. Jika gagal, **rebuild** dengan `node-gyp` atau `cmake-js` di environment Bun.
    
3. Untuk performa maksimal, tulis ulang menggunakan **Bun’s C++ API** (opsional, tapi ideal).
    

---

## 🚀 Studi Kasus: TensorFlow.js di Node vs Bun

| Aspek | Node.js (`@tensorflow/tfjs-node`) | Bun |
| --- | --- | --- |
| Engine | V8 | JavaScriptCore |
| Native binding | TensorFlow C++ binding | Menggunakan kompatibilitas ABI Node |
| Performa | Sangat cepat, stabil | Hampir setara, kadang perlu patch |
| Masalah umum | Build besar (500MB+) | Kadang gagal load `.node` |
| Solusi | `npm rebuild` | Plugin atau patch ABI |

---

## 🧭 Kesimpulan

| Konsep | Penjelasan |
| --- | --- |
| **Native binding** | Penghubung antara JS dan C++ |
| **ABI** | Standar komunikasi biner antar library |
| **Node.js** | Gunakan N-API dan ABI versi tertentu |
| **Bun** | Meniru ABI Node sebagian, gunakan JavaScriptCore |
| **Konversi** | Mudah secara kode JS, tapi perlu hati-hati di layer C++ |
| **Saran** | Gunakan Bun untuk inference ringan atau web backend, dan Node.js untuk training AI besar |

---

## 📘 Penutup

Pemahaman tentang **Native Binding dan ABI** penting bagi developer fullstack modern — terutama ketika mulai menggabungkan JavaScript dengan **AI, Machine Learning, atau komputasi berat**.  
Mengetahui cara kerja layer ini membuatmu tidak hanya bisa memakai library, tapi juga **memahami mengapa library itu bisa (atau tidak bisa) berjalan di environment tertentu.**

> “Ketika seorang programmer memahami batas mesin dan bahasa, ia bukan sekadar pengguna teknologi, tapi pencipta peradaban digital.”