Serialisasi, bahasa bersama mesin-mesin.

Aplikasi web yang khas adalah dua mesin di tempat berbeda, terhubung lewat internet. Klien: frontend-nya, sering aplikasi JavaScript (React, Angular, Vue) yang berjalan di browser seperti Chrome, bicara ke server, backend-nya, yang mungkin berjalan di localhost atau di tempat jauh di AWS, GCP, atau Azure. Mereka berkomunikasi lewat protokol jaringan: HTTP (REST API tradisional), gRPC, atau WebSocket. Manual ini berasumsi HTTP/REST, karena itu yang masih paling umum.

Inilah jebakannya. Klien bisa jadi JavaScript dan server bisa jadi Rust, dan kedua bahasa itu memperlakukan data dengan cara yang sangat berbeda:

• JavaScript dinamis dan tidak dikompilasi, tipe-nya longgar dan diputuskan saat runtime.
• Rust dikompilasi dan sangat ketat soal tipe.

Jadi saat klien JavaScript mengirim objek seperti { name: "..." } di body request, server Rust tidak bisa memahami secara natif struktur data JavaScript, tipe datanya sendiri tidak mirip sama sekali dengan milik JavaScript. Masalah yang sama terjadi terbalik untuk respons. Dua mesin, dua dunia internal yang tak kompatibel, satu kabel di antara keduanya.

Solusinya: kedua sisi menyepakati satu format standar yang umum untuk data di kabel. Setiap mesin mengonversi ke dalam format itu sebelum mengirim, dan keluar dari format itu setelah menerima.

Jika masalah ini diserahkan kepada Anda dalam keadaan dingin, dua mesin di lokasi berbeda, terhubung lewat internet, yang harus bertukar data secara language-agnostic, solusi yang jelas adalah mendefinisikan standar bersama.

Dengan kesepakatan itu, klien mengonversi logika natifnya (misalnya dari JavaScript) ke dalam standar sebelum mengirim; server membaca standar itu dan mengonversinya ke tipe natifnya sendiri (misalnya struct Rust); ia bekerja, mengonversi respons kembali ke standar, dan mengirimnya; klien mem-parse-nya kembali ke JavaScript. Round-trip itu adalah serialisasi dan deserialisasi. Dalam satu kalimat: mengonversi data ke dan dari format bersama saat transmisi (atau penyimpanan), supaya bisa dipahami lintas bahasa dan domain.

Banyak sekali standar serialisasi, tapi mereka jatuh ke dua keluarga.

• Format berbasis teks: bisa dibaca manusia. JSON, YAML, dan XML. Anda bisa membuka payload-nya dan membacanya.
• Format biner: dikompilasi menjadi biner mentah untuk transmisi yang sangat efisien dan ringkas. Protobuf (Protocol Buffers) dan Avro yang populer. Tidak dimaksudkan dibaca mata.

YAML dan XML masih dipakai untuk serialisasi, tapi tidak begitu sering untuk komunikasi HTTP. Untuk HTTP REST API tradisional, pilihan bawaan adalah JSON.

Untuk komunikasi HTTP REST API tradisional, JSON adalah standar serialisasi paling populer, dipakai kira-kira 80% dari waktu.

Kenapa ia menang

• Bisa dibaca manusia. JSON dirancang untuk dibaca orang; Anda bisa melirik payload dan langsung mengerti. Itu salah satu daya jual terkuatnya.
• Tipe data fundamental. Tipe nilainya memetakan dengan rapi ke konsep yang sudah diketahui setiap programmer.

Di mana Anda akan menjumpainya

• Transmisi HTTP: body request/response REST API (fokus di sini).
• Logging: pilihan yang sangat populer untuk log aplikasi dan server saat runtime.
• File konfigurasi: config aplikasi dan tool.

JSON punya sangat sedikit aturan, itulah intinya. Ini contoh objek khas, dengan anotasi untuk setiap aturan yang disebut sumber:

Aturannya, dijabarkan

• Objek JSON dimulai { dan diakhiri }.
• Key harus string yang dibungkus tanda kutip ganda: mis. "name":. Tidak ada tipe data lain yang bisa jadi key. (Kutip ganda, selalu, bukan kutip tunggal.)
• Nilai terbatas pada tipe fundamental: string, angka, boolean, larik, atau objek bertingkat lain.
• Objek bertingkat mengikuti aturan yang sama persis secara rekursif: kurung kurawal, key string berkutip, dan nilai bertipe fundamental yang sama. JSON bisa menyarang sedalam yang Anda suka.

Saat data melintasi internet ia melewati banyak lapisan jaringan, model OSI. Anda tidak perlu menguasai paket IP dan frame data untuk jadi engineer backend; gambaran tingkat tinggi cukup. Dua ujung tumpukan adalah lapisan aplikasi (atas) dan lapisan fisik (bawah); ada beberapa lapisan di antaranya, dan tumpukan yang sama ada di klien dan server.

Merangkai setiap bagian, inilah round-trip lengkap dalam request sungguhan, fenomena yang secara utuh adalah serialisasi & deserialisasi.

Dalam kata-kata: klien mengumpulkan input, men-serialize-nya menjadi string JSON di body request, lalu mengirimkannya; bit-bit melintasi internet; server men-deserialize JSON menjadi tipe natifnya, menjalankan logika bisnis (mis. menyimpan ke database), men-serialize responsnya kembali ke JSON, dan mengirimnya; klien men-deserialize JSON itu menjadi objek JavaScript dan memperbarui UI. Seluruh alur itulah yang kita sebut serialisasi dan deserialisasi, fenomena yang sebagian besar cukup Anda ketahui keberadaannya; ia punya sangat sedikit konsep sendiri.

Go men-serialize ke/dari JSON dengan paket standar encoding/json: Marshal = serialize, Unmarshal = deserialize. Pilar-pilarnya muncul lewat interface (abstraksi + polimorfisme), field tak-terekspor + struct tag (enkapsulasi), dan embedding (komposisi, inheritance ala Go). Pilar ditandai tag OOP.

package main

import ("encoding/json"; "fmt"; "time")

// ABSTRACTION: Serializer names a capability, "turn data into
// bytes and back", without binding to a concrete format. Code
// depends on this contract, so JSON could be swapped for another
// format with zero changes to callers.
type Serializer interface {
    Serialize(v any) ([]byte, error)   // native -> common format
    Deserialize(data []byte, v any) error // common format -> native
}

// POLYMORPHISM: JSONSerializer implements Serializer. Any other
// format (YAML, Protobuf) could implement the same interface and
// be used interchangeably through a Serializer variable.
type JSONSerializer struct{}

func (JSONSerializer) Serialize(v any) ([]byte, error) {
    return json.Marshal(v)   // SERIALIZE: struct -> JSON bytes
}
func (JSONSerializer) Deserialize(data []byte, v any) error {
    return json.Unmarshal(data, v) // DESERIALIZE: JSON bytes -> struct
}

// "INHERITANCE" via COMPOSITION: BaseModel holds shared fields;
// embedding it into User reuses them (and their json tags).
type BaseModel struct {
    ID        int       `json:"id"`         // tag = the JSON key name
    CreatedAt time.Time `json:"created_at"`
}

// ENCAPSULATION: an exported struct whose JSON shape is controlled
// by tags. "password" is unexported (lowercase) -> private AND
// invisible to the JSON encoder, so it never leaks over the wire.
type User struct {
    BaseModel            // embedded -> inherits ID, CreatedAt
    Name    string      `json:"name"`
    Active  bool        `json:"active"`
    Address Address     `json:"address"` // nested object
    password string     // unexported: hidden from JSON output
}

type Address struct {
    Country string `json:"country"`
    Phone   int    `json:"phone"`
}

func main() {
    var codec Serializer = JSONSerializer{} // program to the interface

    u := User{
        BaseModel: BaseModel{ID: 1, CreatedAt: time.Now()},
        Name:      "Ada", Active: true,
        Address:   Address{Country: "India", Phone: 123456},
    }

    // SERIALIZE, native Go struct into the common JSON format
    out, _ := codec.Serialize(u)
    fmt.Println(string(out))
    // {"id":1,"created_at":"...","name":"Ada","active":true,
    //  "address":{"country":"India","phone":123456}}

    // DESERIALIZE, JSON received over HTTP back into a Go struct
    incoming := []byte(`{"name":"Lin","address":{"country":"IN","phone":42}}`)
    var back User
    codec.Deserialize(incoming, &back)
    fmt.Println(back.Name, back.Address.Country) // Lin IN
}

Python memakai modul json bawaan: json.dumps = serialize (dump ke string), json.loads = deserialize (load dari string). Arsitektur OOP yang sama: kontrak ABC, inheritance, polimorfisme, dan atribut privat.

import json
from abc import ABC, abstractmethod
from dataclasses import dataclass, asdict, field

# ABSTRACTION: Serializer is an Abstract Base Class. The
# @abstractmethod forces subclasses to implement both directions.
# You cannot instantiate Serializer itself, it is a pure contract.
class Serializer(ABC):
    @abstractmethod
    def serialize(self, obj) -> str: ...      # native -> common
    @abstractmethod
    def deserialize(self, data: str): ...      # common -> native

# INHERITANCE + POLYMORPHISM: JSONSerializer IS-A Serializer and
# overrides both methods. A YamlSerializer could subclass the same
# ABC and be dropped in wherever a Serializer is expected.
class JSONSerializer(Serializer):
    def serialize(self, obj) -> str:
        return json.dumps(obj)               # SERIALIZE: dict -> JSON text
    def deserialize(self, data: str):
        return json.loads(data)              # DESERIALIZE: JSON text -> dict

# INHERITANCE: BaseModel is a shared parent (id, timestamps).
@dataclass
class BaseModel:
    id: int = 0

@dataclass
class Address:
    country: str
    phone: int                              # nested object

# ENCAPSULATION: __password is name-mangled (-> _User__password),
# effectively private, and to_dict() chooses what leaves the
# object, the secret never appears in the serialized output.
@dataclass
class User(BaseModel):                     # IS-A BaseModel
    name: str = ""
    active: bool = True
    address: Address | None = None
    __password: str = ""                  # private; excluded below

    def to_dict(self) -> dict:
        d = asdict(self)
        d.pop("_User__password", None)        # keep the secret out
        return d

if __name__ == "__main__":
    codec: Serializer = JSONSerializer()    # program to the contract

    user = User(id=1, name="Ada",
                address=Address("India", 123456))

    # SERIALIZE, native object into the common JSON format
    payload = codec.serialize(user.to_dict())
    print(payload)
    # {"id": 1, "name": "Ada", "active": true,
    #  "address": {"country": "India", "phone": 123456}}

    # DESERIALIZE, JSON received over HTTP back into native data
    incoming = '{"name": "Lin", "address": {"country": "IN", "phone": 42}}'
    data = codec.deserialize(incoming)
    print(data["name"], data["address"]["country"])  # Lin IN

Setiap istilah dari sumber, dalam satu tempat.