Serialization, the shared language of machines.

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

// ABSTRACTION: JavaScript has no interface keyword, so the contract is a base
// class whose methods refuse to run. Callers depend only on this shape, so
// JSON could be swapped for another format without touching them.
class Serializer {
  serialize(value) { throw new Error("serialize() must be implemented"); }    // native -> common
  deserialize(data) { throw new Error("deserialize() must be implemented"); } // common -> native
}

// POLYMORPHISM: JsonSerializer implements the contract. Any other format
// (YAML, Protobuf) can extend the same base and be swapped in unchanged.
class JsonSerializer extends Serializer {
  serialize(value) {
    return JSON.stringify(value);  // SERIALIZE: object -> JSON text
  }
  deserialize(data) {
    return JSON.parse(data);       // DESERIALIZE: JSON text -> object
  }
}

// "INHERITANCE": BaseModel holds the shared fields; User extends it and
// reuses them, the counterpart of Go's struct embedding.
class BaseModel {
  constructor(id = 0, createdAt = new Date()) {
    this.id = id;
    this.createdAt = createdAt;
  }
}

class Address {
  constructor(country, phone) {
    this.country = country;
    this.phone = phone; // nested object
  }
}

// ENCAPSULATION: #password is private at RUNTIME, so it is both unreachable
// from outside AND invisible to JSON.stringify, the secret never reaches the
// wire. toJSON() is the hook stringify calls: it is JavaScript's answer to
// Go's struct tags, deciding exactly which keys leave the object.
class User extends BaseModel {
  #password;

  constructor({ id, name, active = true, address = null, password = "" }) {
    super(id);
    this.name = name;
    this.active = active;
    this.address = address;
    this.#password = password;
  }

  toJSON() {
    return {
      id: this.id,
      created_at: this.createdAt, // rename on the way out, like a json tag
      name: this.name,
      active: this.active,
      address: this.address,
    };
  }
}

const codec = new JsonSerializer(); // program to the contract

const user = new User({ id: 1, name: "Ada", address: new Address("India", 123456) });

// SERIALIZE, native object into the common JSON format
const payload = codec.serialize(user);
console.log(payload);
// {"id":1,"created_at":"...","name":"Ada","active":true,
//  "address":{"country":"India","phone":123456}}

// DESERIALIZE, JSON received over HTTP back into native data
const incoming = '{"name":"Lin","address":{"country":"IN","phone":42}}';
const data = codec.deserialize(incoming);
console.log(data.name, data.address.country); // Lin IN

// ABSTRACTION: TypeScript has a real interface keyword, so the contract is a
// type the compiler checks. Callers depend only on this shape, so JSON could
// be swapped for another format without touching them.
interface Serializer {
  serialize(value: unknown): string;  // native -> common
  deserialize(data: string): unknown; // common -> native, untrusted until checked
}

// POLYMORPHISM: JsonSerializer implements the contract. Any other format
// (YAML, Protobuf) can implement the same interface and be swapped in unchanged.
class JsonSerializer implements Serializer {
  serialize(value: unknown): string {
    return JSON.stringify(value);  // SERIALIZE: object -> JSON text
  }
  deserialize(data: string): unknown {
    return JSON.parse(data);       // DESERIALIZE: JSON text -> unknown
  }
}

// "INHERITANCE": BaseModel holds the shared fields; User extends it and
// reuses them, the counterpart of Go's struct embedding.
class BaseModel {
  id: number;
  createdAt: Date;

  constructor(id = 0, createdAt = new Date()) {
    this.id = id;
    this.createdAt = createdAt;
  }
}

interface Address {
  country: string;
  phone: number; // nested object
}

// The exact keys that leave a User. With the wire shape declared as a type,
// a misspelled or forgotten key in toJSON() is a compile error.
interface UserJSON {
  id: number;
  created_at: Date; // rename on the way out, like a json tag
  name: string;
  active: boolean;
  address: Address | null;
}

interface UserInit {
  id: number;
  name: string;
  active?: boolean;
  address?: Address | null;
  password?: string;
}

// ENCAPSULATION: #password is private at RUNTIME, so it is both unreachable
// from outside AND invisible to JSON.stringify. TypeScript's `private` keyword
// is not enough on its own: it only hides the field from the compiler, and
// JSON.stringify would still write it out. toJSON() decides which keys leave.
class User extends BaseModel {
  name: string;
  active: boolean;
  address: Address | null;
  #password: string;

  constructor({ id, name, active = true, address = null, password = "" }: UserInit) {
    super(id);
    this.name = name;
    this.active = active;
    this.address = address;
    this.#password = password;
  }

  toJSON(): UserJSON {
    return {
      id: this.id,
      created_at: this.createdAt,
      name: this.name,
      active: this.active,
      address: this.address,
    };
  }
}

// What we EXPECT a client to send. JSON.parse can't promise that shape, so a
// type guard checks it at runtime before the compiler lets us use the data.
interface IncomingUser {
  name: string;
  address: Address;
}

function isIncomingUser(value: unknown): value is IncomingUser {
  const v = value as Partial<IncomingUser> | null;
  return typeof v?.name === "string"
    && typeof v.address?.country === "string"
    && typeof v.address?.phone === "number";
}

const codec: Serializer = new JsonSerializer(); // program to the contract

const user = new User({ id: 1, name: "Ada", address: { country: "India", phone: 123456 } });

// SERIALIZE, native object into the common JSON format
const payload = codec.serialize(user);
console.log(payload);
// {"id":1,"created_at":"...","name":"Ada","active":true,
//  "address":{"country":"India","phone":123456}}

// DESERIALIZE, JSON received over HTTP back into native data
const incoming = '{"name":"Lin","address":{"country":"IN","phone":42}}';
const data = codec.deserialize(incoming); // unknown: data.name won't compile yet
if (isIncomingUser(data)) {
  console.log(data.name, data.address.country); // Lin IN
}

// Java has no JSON in its standard library; Jackson is the de facto standard.
// Dependency: tools.jackson.core:jackson-databind (Jackson 3)
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import java.time.Instant;
import tools.jackson.databind.json.JsonMapper;

// ABSTRACTION: Serializer is a real interface, a pure contract. Callers
// depend only on it, so JSON could be swapped for another format without
// touching them.
interface Serializer {
    String serialize(Object value);                 // native -> common
    <T> T deserialize(String data, Class<T> type);  // common -> native
}

// POLYMORPHISM: JsonSerializer implements the contract. A YamlSerializer
// could implement the same interface and be swapped in unchanged.
class JsonSerializer implements Serializer {
    private final JsonMapper mapper = new JsonMapper(); // Jackson's JSON codec

    @Override
    public String serialize(Object value) {
        return mapper.writeValueAsString(value);    // SERIALIZE: object -> JSON text
    }

    @Override
    public <T> T deserialize(String data, Class<T> type) {
        return mapper.readValue(data, type);        // DESERIALIZE: JSON text -> object
    }
}

// "INHERITANCE": BaseModel holds the shared fields; User extends it and
// reuses them, the counterpart of Go's struct embedding.
abstract class BaseModel {
    @JsonProperty("id")
    private final long id;
    @JsonProperty("created_at")   // rename on the way out, like a json tag
    private final Instant createdAt;

    protected BaseModel(long id) {
        this.id = id;
        this.createdAt = Instant.now();
    }
}

record Address(String country, int phone) {} // nested object; records map to JSON as-is

// ENCAPSULATION: every field is private. Annotations are Java's answer to
// Go's struct tags: @JsonProperty lets a field onto the wire, @JsonIgnore
// keeps password off it for good, even if someone adds a getter later.
@JsonPropertyOrder({"id", "created_at", "name", "active", "address"})
class User extends BaseModel {
    @JsonProperty private final String name;
    @JsonProperty private final boolean active;
    @JsonProperty private final Address address;
    @JsonIgnore   private final String password;

    User(long id, String name, Address address, String password) {
        super(id);
        this.name = name;
        this.active = true;
        this.address = address;
        this.password = password;
    }
}

// What we EXPECT a client to send. readValue binds the JSON straight into
// this typed record, and a value of the wrong type (text where phone expects
// a number) throws instead of slipping through.
record IncomingUser(String name, Address address) {}

public class Serialize {
    public static void main(String[] args) {
        Serializer codec = new JsonSerializer(); // program to the contract

        User user = new User(1, "Ada", new Address("India", 123456), "s3cret");

        // SERIALIZE, native object into the common JSON format
        String payload = codec.serialize(user);
        System.out.println(payload);
        // {"id":1,"created_at":"...","name":"Ada","active":true,
        //  "address":{"country":"India","phone":123456}}

        // DESERIALIZE, JSON received over HTTP back into a typed record
        String incoming = """
                {"name":"Lin","address":{"country":"IN","phone":42}}""";
        IncomingUser data = codec.deserialize(incoming, IncomingUser.class);
        System.out.println(data.name() + " " + data.address().country()); // Lin IN
    }
}