Coupling, Cohesion, DRY, KISS and YAGNI.

# sms_v1.py: the order-status SMS, written out in four handlers
def send_sms(phone: str, text: str) -> None:
    print(f"sms to {phone}: {text}")


def on_placed(order: dict) -> None:
    send_sms(order["phone"], f"Hi {order['name']}, your order #{order['id']} is placed. Total {order['total']} rupees.")


def on_accepted(order: dict) -> None:
    send_sms(order["phone"], f"Hi {order['name']}, your order #{order['id']} is accepted by the restaurant.")


def on_picked_up(order: dict) -> None:
    send_sms(order["phone"], f"Hi {order['name']}, order {order['id']} is on its way.")  # copied, then edited by hand: drifted


def on_delivered(order: dict) -> None:
    send_sms(order["phone"], f"Hi {order['name']}, your order #{order['id']} was delivered. Enjoy!")


order = {"id": 1001, "name": "Asha", "phone": "90000-00001", "total": 590}
for handler in (on_placed, on_accepted, on_picked_up, on_delivered):
    handler(order)

// SmsV1.java: the order-status SMS, written out in four handlers
class SmsV1 {
    record Order(int id, String name, String phone, int total) {}

    static void sendSms(String phone, String text) { System.out.println("sms to " + phone + ": " + text); }

    static void onPlaced(Order o) { sendSms(o.phone(), "Hi " + o.name() + ", your order #" + o.id() + " is placed. Total " + o.total() + " rupees."); }

    static void onAccepted(Order o) { sendSms(o.phone(), "Hi " + o.name() + ", your order #" + o.id() + " is accepted by the restaurant."); }

    static void onPickedUp(Order o) { sendSms(o.phone(), "Hi " + o.name() + ", order " + o.id() + " is on its way."); } // copied, then edited by hand: drifted

    static void onDelivered(Order o) { sendSms(o.phone(), "Hi " + o.name() + ", your order #" + o.id() + " was delivered. Enjoy!"); }

    public static void main(String[] args) {
        Order order = new Order(1001, "Asha", "90000-00001", 590);
        onPlaced(order);
        onAccepted(order);
        onPickedUp(order);
        onDelivered(order);
    }
}

// sms_v1.cpp: the order-status SMS, written out in four handlers
#include <iostream>
#include <string>

struct Order {
    int id;
    std::string name;
    std::string phone;
    int total;
};

void send_sms(const std::string& phone, const std::string& text) { std::cout << "sms to " << phone << ": " << text << "\n"; }

void on_placed(const Order& o) {
    send_sms(o.phone, "Hi " + o.name + ", your order #" + std::to_string(o.id) + " is placed. Total " + std::to_string(o.total) + " rupees.");
}

void on_accepted(const Order& o) { send_sms(o.phone, "Hi " + o.name + ", your order #" + std::to_string(o.id) + " is accepted by the restaurant."); }

void on_picked_up(const Order& o) { send_sms(o.phone, "Hi " + o.name + ", order " + std::to_string(o.id) + " is on its way."); }  // copied, then edited by hand: drifted

void on_delivered(const Order& o) { send_sms(o.phone, "Hi " + o.name + ", your order #" + std::to_string(o.id) + " was delivered. Enjoy!"); }

int main() {
    Order order{1001, "Asha", "90000-00001", 590};
    on_placed(order);
    on_accepted(order);
    on_picked_up(order);
    on_delivered(order);
}

// smsV1.js: the order-status SMS, written out in four handlers
function sendSms(phone, text) {
  console.log(`sms to ${phone}: ${text}`);
}

function onPlaced(order) {
  sendSms(order.phone, `Hi ${order.name}, your order #${order.id} is placed. Total ${order.total} rupees.`);
}

function onAccepted(order) {
  sendSms(order.phone, `Hi ${order.name}, your order #${order.id} is accepted by the restaurant.`);
}

function onPickedUp(order) {
  sendSms(order.phone, `Hi ${order.name}, order ${order.id} is on its way.`); // copied, then edited by hand: drifted
}

function onDelivered(order) {
  sendSms(order.phone, `Hi ${order.name}, your order #${order.id} was delivered. Enjoy!`);
}

const order = { id: 1001, name: "Asha", phone: "90000-00001", total: 590 };
for (const handler of [onPlaced, onAccepted, onPickedUp, onDelivered]) handler(order);

# sms_v2.py: one place builds an order-status SMS; each status only supplies its own wording
STATUS_TEXT = {
    "placed": "is placed. Total {total} rupees.",
    "accepted": "is accepted by the restaurant.",
    "picked_up": "is on its way.",
    "delivered": "was delivered. Enjoy!",
}


def status_sms(order: dict, status: str, tracking: str = "") -> str:  # the greeting and the id format live here only
    text = STATUS_TEXT[status].replace("{total}", str(order["total"]))
    sms = f"Hi {order['name']}, your order #{order['id']} {text}"
    return f"{sms} Track: {tracking}" if tracking else sms


def notify(order: dict, status: str, tracking: str = "") -> None:  # the recipient rule lives here only
    print(f"sms to {order['phone']}: {status_sms(order, status, tracking)}")


order = {"id": 1001, "name": "Asha", "phone": "90000-00001", "total": 590}
for status in STATUS_TEXT:
    notify(order, status)
print("with a tracking link, one new parameter in one place:")
for status in STATUS_TEXT:
    notify(order, status, "t.example/1001")

// SmsV2.java: one place builds an order-status SMS; each status only supplies its own wording
import java.util.LinkedHashMap;
import java.util.Map;

class SmsV2 {
    record Order(int id, String name, String phone, int total) {}

    static final Map<String, String> STATUS_TEXT = new LinkedHashMap<>();
    static {
        STATUS_TEXT.put("placed", "is placed. Total {total} rupees.");
        STATUS_TEXT.put("accepted", "is accepted by the restaurant.");
        STATUS_TEXT.put("picked_up", "is on its way.");
        STATUS_TEXT.put("delivered", "was delivered. Enjoy!");
    }

    static String statusSms(Order o, String status, String tracking) { // the greeting and the id format live here only
        String text = STATUS_TEXT.get(status).replace("{total}", String.valueOf(o.total()));
        String sms = "Hi " + o.name() + ", your order #" + o.id() + " " + text;
        return tracking.isEmpty() ? sms : sms + " Track: " + tracking;
    }

    static void notify(Order o, String status, String tracking) { // the recipient rule lives here only
        System.out.println("sms to " + o.phone() + ": " + statusSms(o, status, tracking));
    }

    public static void main(String[] args) {
        Order order = new Order(1001, "Asha", "90000-00001", 590);
        for (String status : STATUS_TEXT.keySet()) notify(order, status, "");
        System.out.println("with a tracking link, one new parameter in one place:");
        for (String status : STATUS_TEXT.keySet()) notify(order, status, "t.example/1001");
    }
}

// sms_v2.cpp: one place builds an order-status SMS; each status only supplies its own wording
#include <iostream>
#include <string>
#include <utility>
#include <vector>

struct Order {
    int id;
    std::string name;
    std::string phone;
    int total;
};

const std::vector<std::pair<std::string, std::string>> STATUS_TEXT = {
    {"placed", "is placed. Total {total} rupees."},
    {"accepted", "is accepted by the restaurant."},
    {"picked_up", "is on its way."},
    {"delivered", "was delivered. Enjoy!"},
};

std::string status_sms(const Order& o, std::string text, const std::string& tracking) {  // the greeting and the id format live here only
    auto at = text.find("{total}");
    if (at != std::string::npos) text.replace(at, 7, std::to_string(o.total));
    std::string sms = "Hi " + o.name + ", your order #" + std::to_string(o.id) + " " + text;
    return tracking.empty() ? sms : sms + " Track: " + tracking;
}

void notify(const Order& o, const std::string& text, const std::string& tracking) {  // the recipient rule lives here only
    std::cout << "sms to " << o.phone << ": " << status_sms(o, text, tracking) << "\n";
}

int main() {
    Order order{1001, "Asha", "90000-00001", 590};
    for (const auto& s : STATUS_TEXT) notify(order, s.second, "");
    std::cout << "with a tracking link, one new parameter in one place:\n";
    for (const auto& s : STATUS_TEXT) notify(order, s.second, "t.example/1001");
}

// smsV2.js: one place builds an order-status SMS; each status only supplies its own wording
const STATUS_TEXT = {
  placed: "is placed. Total {total} rupees.",
  accepted: "is accepted by the restaurant.",
  picked_up: "is on its way.",
  delivered: "was delivered. Enjoy!",
};

function statusSms(order, status, tracking = "") { // the greeting and the id format live here only
  const text = STATUS_TEXT[status].replace("{total}", String(order.total));
  const sms = `Hi ${order.name}, your order #${order.id} ${text}`;
  return tracking ? `${sms} Track: ${tracking}` : sms;
}

function notify(order, status, tracking = "") { // the recipient rule lives here only
  console.log(`sms to ${order.phone}: ${statusSms(order, status, tracking)}`);
}

const order = { id: 1001, name: "Asha", phone: "90000-00001", total: 590 };
for (const status of Object.keys(STATUS_TEXT)) notify(order, status);
console.log("with a tracking link, one new parameter in one place:");
for (const status of Object.keys(STATUS_TEXT)) notify(order, status, "t.example/1001");

# reach_v1.py: a grab-bag class whose three jobs each reach through an order's parts
class Address:
    def __init__(self, city: str) -> None:
        self.city = city


class Customer:
    def __init__(self, name: str, phone: str, address: Address) -> None:
        self.name, self.phone, self.address = name, phone, address


class Restaurant:
    def __init__(self, name: str, address: Address) -> None:
        self.name, self.address = name, address


class Order:
    def __init__(self, customer: Customer, restaurant: Restaurant, subtotal: int) -> None:
        self.customer, self.restaurant, self.subtotal = customer, restaurant, subtotal


class OrderUtils:  # a grab bag: pricing, privacy and display, all reaching inside an order
    @staticmethod
    def delivery_fee(order: Order) -> int:
        return 20 if order.customer.address.city == order.restaurant.address.city else 45

    @staticmethod
    def masked_phone(order: Order) -> str:
        phone = order.customer.phone
        return phone[:2] + "X" * (len(phone) - 4) + phone[-2:]

    @staticmethod
    def label(order: Order) -> str:
        return f"{order.customer.name}: {order.subtotal + OrderUtils.delivery_fee(order)} rupees"


order = Order(Customer("Asha", "9000000001", Address("Pune")), Restaurant("Biryani House", Address("Pune")), 500)
print("fee:", OrderUtils.delivery_fee(order))
print("phone:", OrderUtils.masked_phone(order))
print("label:", OrderUtils.label(order))

// ReachV1.java: a grab-bag class whose three jobs each reach through an order's parts
class ReachV1 {
    record Address(String city) {}

    record Customer(String name, String phone, Address address) {}

    record Restaurant(String name, Address address) {}

    record Order(Customer customer, Restaurant restaurant, int subtotal) {}

    static final class OrderUtils { // a grab bag: pricing, privacy and display, all reaching inside an order
        static int deliveryFee(Order order) {
            return order.customer().address().city().equals(order.restaurant().address().city()) ? 20 : 45;
        }

        static String maskedPhone(Order order) {
            String phone = order.customer().phone();
            return phone.substring(0, 2) + "X".repeat(phone.length() - 4) + phone.substring(phone.length() - 2);
        }

        static String label(Order order) {
            return order.customer().name() + ": " + (order.subtotal() + deliveryFee(order)) + " rupees";
        }
    }

    public static void main(String[] args) {
        Order order = new Order(new Customer("Asha", "9000000001", new Address("Pune")), new Restaurant("Biryani House", new Address("Pune")), 500);
        System.out.println("fee: " + OrderUtils.deliveryFee(order));
        System.out.println("phone: " + OrderUtils.maskedPhone(order));
        System.out.println("label: " + OrderUtils.label(order));
    }
}

// reach_v1.cpp: a grab-bag class whose three jobs each reach through an order's parts
#include <iostream>
#include <string>

struct Address {
    std::string city;
};

struct Customer {
    std::string name;
    std::string phone;
    Address address;
};

struct Restaurant {
    std::string name;
    Address address;
};

struct Order {
    Customer customer;
    Restaurant restaurant;
    int subtotal;
};

struct OrderUtils {  // a grab bag: pricing, privacy and display, all reaching inside an order
    static int delivery_fee(const Order& order) { return order.customer.address.city == order.restaurant.address.city ? 20 : 45; }

    static std::string masked_phone(const Order& order) {
        const std::string& phone = order.customer.phone;
        return phone.substr(0, 2) + std::string(phone.size() - 4, 'X') + phone.substr(phone.size() - 2);
    }

    static std::string label(const Order& order) {
        return order.customer.name + ": " + std::to_string(order.subtotal + delivery_fee(order)) + " rupees";
    }
};

int main() {
    Order order{{"Asha", "9000000001", {"Pune"}}, {"Biryani House", {"Pune"}}, 500};
    std::cout << "fee: " << OrderUtils::delivery_fee(order) << "\n";
    std::cout << "phone: " << OrderUtils::masked_phone(order) << "\n";
    std::cout << "label: " << OrderUtils::label(order) << "\n";
}

// reachV1.js: a grab-bag class whose three jobs each reach through an order's parts
class Address {
  constructor(city) {
    this.city = city;
  }
}

class Customer {
  constructor(name, phone, address) {
    Object.assign(this, { name, phone, address });
  }
}

class Restaurant {
  constructor(name, address) {
    Object.assign(this, { name, address });
  }
}

class Order {
  constructor(customer, restaurant, subtotal) {
    Object.assign(this, { customer, restaurant, subtotal });
  }
}

class OrderUtils { // a grab bag: pricing, privacy and display, all reaching inside an order
  static deliveryFee(order) {
    return order.customer.address.city === order.restaurant.address.city ? 20 : 45;
  }
  static maskedPhone(order) {
    const phone = order.customer.phone;
    return phone.slice(0, 2) + "X".repeat(phone.length - 4) + phone.slice(-2);
  }
  static label(order) {
    return `${order.customer.name}: ${order.subtotal + OrderUtils.deliveryFee(order)} rupees`;
  }
}

const order = new Order(new Customer("Asha", "9000000001", new Address("Pune")), new Restaurant("Biryani House", new Address("Pune")), 500);
console.log("fee:", OrderUtils.deliveryFee(order));
console.log("phone:", OrderUtils.maskedPhone(order));
console.log("label:", OrderUtils.label(order));

# reach_v2.py: each class answers questions about its own data; callers ask one object, one step away
class Address:
    def __init__(self, city: str) -> None:
        self.city = city


class Customer:
    def __init__(self, name: str, phone: str, address: Address) -> None:
        self.name, self.phone, self.address = name, phone, address

    def city(self) -> str:
        return self.address.city

    def masked_phone(self) -> str:  # privacy rules live with the phone number
        return self.phone[:2] + "X" * (len(self.phone) - 4) + self.phone[-2:]


class Restaurant:
    def __init__(self, name: str, address: Address) -> None:
        self.name, self.address = name, address

    def city(self) -> str:
        return self.address.city


def delivery_fee(origin, destination) -> int:  # needs only two things that know their city
    return 20 if origin.city() == destination.city() else 45


class Order:
    def __init__(self, customer: Customer, restaurant: Restaurant, subtotal: int) -> None:
        self.customer, self.restaurant, self.subtotal = customer, restaurant, subtotal

    def label(self) -> str:
        return f"{self.customer.name}: {self.subtotal + delivery_fee(self.restaurant, self.customer)} rupees"


class StubPlace:  # a test double that only knows its city
    def __init__(self, city: str) -> None:
        self._city = city

    def city(self) -> str:
        return self._city


order = Order(Customer("Asha", "9000000001", Address("Pune")), Restaurant("Biryani House", Address("Pune")), 500)
print("fee:", delivery_fee(order.restaurant, order.customer))
print("phone:", order.customer.masked_phone())
print("label:", order.label())
print("fee between two stub places:", delivery_fee(StubPlace("Pune"), StubPlace("Pune")))

// ReachV2.java: each class answers questions about its own data; callers ask one object, one step away
class ReachV2 {
    record Address(String city) {}

    interface Place { String city(); } // anything that knows which city it is in

    record Customer(String name, String phone, Address address) implements Place {
        public String city() { return address.city(); }

        String maskedPhone() { // privacy rules live with the phone number
            return phone.substring(0, 2) + "X".repeat(phone.length() - 4) + phone.substring(phone.length() - 2);
        }
    }

    record Restaurant(String name, Address address) implements Place {
        public String city() { return address.city(); }
    }

    static int deliveryFee(Place origin, Place destination) { // needs only two things that know their city
        return origin.city().equals(destination.city()) ? 20 : 45;
    }

    record Order(Customer customer, Restaurant restaurant, int subtotal) {
        String label() { return customer.name() + ": " + (subtotal + deliveryFee(restaurant, customer)) + " rupees"; }
    }

    record StubPlace(String city) implements Place {} // a test double that only knows its city

    public static void main(String[] args) {
        Order order = new Order(new Customer("Asha", "9000000001", new Address("Pune")), new Restaurant("Biryani House", new Address("Pune")), 500);
        System.out.println("fee: " + deliveryFee(order.restaurant(), order.customer()));
        System.out.println("phone: " + order.customer().maskedPhone());
        System.out.println("label: " + order.label());
        System.out.println("fee between two stub places: " + deliveryFee(new StubPlace("Pune"), new StubPlace("Pune")));
    }
}

// reach_v2.cpp: each class answers questions about its own data; callers ask one object, one step away
#include <iostream>
#include <string>
#include <utility>

struct Address {
    std::string city;
};

class Place {  // anything that knows which city it is in
public:
    virtual ~Place() = default;
    virtual std::string city() const = 0;
};

struct Customer : Place {
    std::string name;
    std::string phone;
    Address address;
    Customer(std::string n, std::string p, Address a) : name(std::move(n)), phone(std::move(p)), address(std::move(a)) {}
    std::string city() const override { return address.city; }
    std::string masked_phone() const {  // privacy rules live with the phone number
        return phone.substr(0, 2) + std::string(phone.size() - 4, 'X') + phone.substr(phone.size() - 2);
    }
};

struct Restaurant : Place {
    std::string name;
    Address address;
    Restaurant(std::string n, Address a) : name(std::move(n)), address(std::move(a)) {}
    std::string city() const override { return address.city; }
};

int delivery_fee(const Place& origin, const Place& destination) {  // needs only two things that know their city
    return origin.city() == destination.city() ? 20 : 45;
}

struct Order {
    Customer customer;
    Restaurant restaurant;
    int subtotal;
    std::string label() const {
        return customer.name + ": " + std::to_string(subtotal + delivery_fee(restaurant, customer)) + " rupees";
    }
};

struct StubPlace : Place {  // a test double that only knows its city
    std::string c;
    explicit StubPlace(std::string city) : c(std::move(city)) {}
    std::string city() const override { return c; }
};

int main() {
    Order order{Customer("Asha", "9000000001", {"Pune"}), Restaurant("Biryani House", {"Pune"}), 500};
    std::cout << "fee: " << delivery_fee(order.restaurant, order.customer) << "\n";
    std::cout << "phone: " << order.customer.masked_phone() << "\n";
    std::cout << "label: " << order.label() << "\n";
    std::cout << "fee between two stub places: " << delivery_fee(StubPlace("Pune"), StubPlace("Pune")) << "\n";
}

// reachV2.js: each class answers questions about its own data; callers ask one object, one step away
class Address {
  constructor(city) {
    this.city = city;
  }
}

class Customer {
  constructor(name, phone, address) {
    Object.assign(this, { name, phone, address });
  }
  city() {
    return this.address.city;
  }
  maskedPhone() { // privacy rules live with the phone number
    return this.phone.slice(0, 2) + "X".repeat(this.phone.length - 4) + this.phone.slice(-2);
  }
}

class Restaurant {
  constructor(name, address) {
    Object.assign(this, { name, address });
  }
  city() {
    return this.address.city;
  }
}

function deliveryFee(origin, destination) { // needs only two things that know their city
  return origin.city() === destination.city() ? 20 : 45;
}

class Order {
  constructor(customer, restaurant, subtotal) {
    Object.assign(this, { customer, restaurant, subtotal });
  }
  label() {
    return `${this.customer.name}: ${this.subtotal + deliveryFee(this.restaurant, this.customer)} rupees`;
  }
}

const stubPlace = (city) => ({ city: () => city }); // a test double that only knows its city

const order = new Order(new Customer("Asha", "9000000001", new Address("Pune")), new Restaurant("Biryani House", new Address("Pune")), 500);
console.log("fee:", deliveryFee(order.restaurant, order.customer));
console.log("phone:", order.customer.maskedPhone());
console.log("label:", order.label());
console.log("fee between two stub places:", deliveryFee(stubPlace("Pune"), stubPlace("Pune")));

# options_v1.py: a settings system built for every option anyone might want; the app reads two
class Option:
    def __init__(self, name: str, default: str, check) -> None:
        self.name, self.value, self.check = name, default, check
        self.listeners = []  # "in case something must react when an option changes"
        self.reads = 0

    def set(self, value: str) -> None:
        if not self.check(value):
            raise ValueError(f"bad value for {self.name}")
        self.value = value
        for listener in self.listeners:
            listener(value)

    def get(self) -> str:
        self.reads += 1
        return self.value


OPTIONS = {o.name: o for o in [
    Option("currency", "INR", lambda v: len(v) == 3),
    Option("tip_percent", "10", lambda v: v.isdigit() and int(v) <= 30),
    Option("rounding", "down", lambda v: v in ("down", "up")),
    Option("locale", "en-IN", lambda v: True),
    Option("receipt_footer", "", lambda v: True),
    Option("theme", "light", lambda v: v in ("light", "dark")),
]}


def tip_line(subtotal: int) -> str:
    percent = int(OPTIONS["tip_percent"].get())
    return f"Tip {percent} percent on {subtotal}: {subtotal * percent // 100} {OPTIONS['currency'].get()}"


print(tip_line(500))
print("options defined:", len(OPTIONS))
print("options the app reads:", sum(1 for o in OPTIONS.values() if o.reads > 0))

// OptionsV1.java: a settings system built for every option anyone might want; the app reads two
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Predicate;

class OptionsV1 {
    static final class Option {
        final String name;
        String value;
        final Predicate<String> check;
        final List<Consumer<String>> listeners = new ArrayList<>(); // "in case something must react when an option changes"
        int reads = 0;

        Option(String name, String value, Predicate<String> check) {
            this.name = name;
            this.value = value;
            this.check = check;
        }

        void set(String v) {
            if (!check.test(v)) throw new IllegalArgumentException("bad value for " + name);
            value = v;
            for (Consumer<String> l : listeners) l.accept(v);
        }

        String get() {
            reads++;
            return value;
        }
    }

    static final Map<String, Option> OPTIONS = new LinkedHashMap<>();

    static void define(String name, String value, Predicate<String> check) { OPTIONS.put(name, new Option(name, value, check)); }

    static String tipLine(int subtotal) {
        int percent = Integer.parseInt(OPTIONS.get("tip_percent").get());
        return "Tip " + percent + " percent on " + subtotal + ": " + (subtotal * percent / 100) + " " + OPTIONS.get("currency").get();
    }

    public static void main(String[] args) {
        define("currency", "INR", v -> v.length() == 3);
        define("tip_percent", "10", v -> v.chars().allMatch(Character::isDigit) && Integer.parseInt(v) <= 30);
        define("rounding", "down", v -> v.equals("down") || v.equals("up"));
        define("locale", "en-IN", v -> true);
        define("receipt_footer", "", v -> true);
        define("theme", "light", v -> v.equals("light") || v.equals("dark"));
        System.out.println(tipLine(500));
        System.out.println("options defined: " + OPTIONS.size());
        System.out.println("options the app reads: " + OPTIONS.values().stream().filter(o -> o.reads > 0).count());
    }
}

// options_v1.cpp: a settings system built for every option anyone might want; the app reads two
#include <algorithm>
#include <cctype>
#include <functional>
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>

struct Option {
    std::string name;
    std::string value;
    std::function<bool(const std::string&)> check;
    std::vector<std::function<void(const std::string&)>> listeners;  // "in case something must react when an option changes"
    int reads = 0;

    void set(const std::string& v) {
        if (!check(v)) throw std::invalid_argument("bad value for " + name);
        value = v;
        for (auto& l : listeners) l(v);
    }
    const std::string& get() {
        ++reads;
        return value;
    }
};

std::vector<Option> options;  // kept in the order they were defined

Option& option(const std::string& name) {
    return *std::find_if(options.begin(), options.end(), [&](const Option& o) { return o.name == name; });
}

std::string tip_line(int subtotal) {
    int percent = std::stoi(option("tip_percent").get());
    return "Tip " + std::to_string(percent) + " percent on " + std::to_string(subtotal) + ": " + std::to_string(subtotal * percent / 100) + " " + option("currency").get();
}

int main() {
    auto digits = [](const std::string& v) { return !v.empty() && std::all_of(v.begin(), v.end(), [](unsigned char c) { return std::isdigit(c) != 0; }); };
    options.push_back({"currency", "INR", [](const std::string& v) { return v.size() == 3; }, {}, 0});
    options.push_back({"tip_percent", "10", [&](const std::string& v) { return digits(v) && std::stoi(v) <= 30; }, {}, 0});
    options.push_back({"rounding", "down", [](const std::string& v) { return v == "down" || v == "up"; }, {}, 0});
    options.push_back({"locale", "en-IN", [](const std::string&) { return true; }, {}, 0});
    options.push_back({"receipt_footer", "", [](const std::string&) { return true; }, {}, 0});
    options.push_back({"theme", "light", [](const std::string& v) { return v == "light" || v == "dark"; }, {}, 0});
    std::cout << tip_line(500) << "\n";
    std::cout << "options defined: " << options.size() << "\n";
    std::cout << "options the app reads: " << std::count_if(options.begin(), options.end(), [](const Option& o) { return o.reads > 0; }) << "\n";
}

// optionsV1.js: a settings system built for every option anyone might want; the app reads two
class Option {
  constructor(name, value, check) {
    Object.assign(this, { name, value, check });
    this.listeners = []; // "in case something must react when an option changes"
    this.reads = 0;
  }
  set(value) {
    if (!this.check(value)) throw new Error(`bad value for ${this.name}`);
    this.value = value;
    for (const listener of this.listeners) listener(value);
  }
  get() {
    this.reads += 1;
    return this.value;
  }
}

const OPTIONS = new Map([
  new Option("currency", "INR", (v) => v.length === 3),
  new Option("tip_percent", "10", (v) => /^\d+$/.test(v) && Number(v) <= 30),
  new Option("rounding", "down", (v) => v === "down" || v === "up"),
  new Option("locale", "en-IN", () => true),
  new Option("receipt_footer", "", () => true),
  new Option("theme", "light", (v) => v === "light" || v === "dark"),
].map((o) => [o.name, o]));

function tipLine(subtotal) {
  const percent = Number(OPTIONS.get("tip_percent").get());
  return `Tip ${percent} percent on ${subtotal}: ${Math.floor((subtotal * percent) / 100)} ${OPTIONS.get("currency").get()}`;
}

console.log(tipLine(500));
console.log("options defined:", OPTIONS.size);
console.log("options the app reads:", [...OPTIONS.values()].filter((o) => o.reads > 0).length);

# options_v2.py: the two values the app uses, written down as two values
CURRENCY = "INR"
TIP_PERCENT = 10


def tip_line(subtotal: int) -> str:
    return f"Tip {TIP_PERCENT} percent on {subtotal}: {subtotal * TIP_PERCENT // 100} {CURRENCY}"


print(tip_line(500))

// OptionsV2.java: the two values the app uses, written down as two values
class OptionsV2 {
    static final String CURRENCY = "INR";
    static final int TIP_PERCENT = 10;

    static String tipLine(int subtotal) {
        return "Tip " + TIP_PERCENT + " percent on " + subtotal + ": " + (subtotal * TIP_PERCENT / 100) + " " + CURRENCY;
    }

    public static void main(String[] args) {
        System.out.println(tipLine(500));
    }
}

// options_v2.cpp: the two values the app uses, written down as two values
#include <iostream>
#include <string>

const std::string CURRENCY = "INR";
const int TIP_PERCENT = 10;

std::string tip_line(int subtotal) {
    return "Tip " + std::to_string(TIP_PERCENT) + " percent on " + std::to_string(subtotal) + ": " + std::to_string(subtotal * TIP_PERCENT / 100) + " " + CURRENCY;
}

int main() { std::cout << tip_line(500) << "\n"; }

// optionsV2.js: the two values the app uses, written down as two values
const CURRENCY = "INR";
const TIP_PERCENT = 10;

function tipLine(subtotal) {
  return `Tip ${TIP_PERCENT} percent on ${subtotal}: ${Math.floor((subtotal * TIP_PERCENT) / 100)} ${CURRENCY}`;
}

console.log(tipLine(500));