Stateless vs Stateful Thinking

package main

import (
	"fmt"
	"strings"
)

// A store maps a user to their cart. Each server copy can have its own, or share one.
type store map[string][]string

// server is one running copy of the backend. It only knows the store it was given.
type server struct{ carts store }

func (s *server) add(user, item string) { s.carts[user] = append(s.carts[user], item) }

func (s *server) view(user string) string {
	if len(s.carts[user]) == 0 {
		return "(empty)"
	}
	return strings.Join(s.carts[user], ", ")
}

func main() {
	// Stateful: each copy keeps carts in its own memory.
	stateful := []*server{{store{}}, {store{}}}
	// Stateless: the copies keep nothing; both use one shared store (think: a database).
	shared := store{}
	stateless := []*server{{shared}, {shared}}

	steps := []struct{ do, item, copy string }{
		{"add", "tea", "A"},
		{"add", "cake", "B"},
		{"view", "", "A"},
		{"view", "", "B"},
		{"restart", "", "A"},
		{"view", "", "A"},
	}
	fmt.Printf("%-10s %-4s %-26s %s\n", "request", "copy", "stateful (own memory)", "stateless (shared store)")
	for _, st := range steps {
		i := strings.Index("AB", st.copy) // the load balancer sent this request to copy A or B
		switch st.do {
		case "add":
			stateful[i].add("alice", st.item)
			stateless[i].add("alice", st.item)
		case "restart":
			stateful[i] = &server{store{}} // a fresh process starts with empty memory
			stateless[i] = &server{shared} // ...but it reconnects to the same shared store
			fmt.Printf("%-10s %-4s %-26s %s\n", "restart", st.copy, "memory wiped", "nothing lost")
			continue
		}
		label := strings.TrimSpace(st.do + " " + st.item)
		fmt.Printf("%-10s %-4s %-26s %s\n", label, st.copy, stateful[i].view("alice"), stateless[i].view("alice"))
	}
}

// A server is one running copy of the backend. It only knows the store it was given:
// a Map from a user to their cart. Each copy can have its own store, or share one.
class Server {
  constructor(carts) {
    this.carts = carts;
  }
  add(user, item) {
    this.carts.set(user, [...(this.carts.get(user) ?? []), item]);
  }
  view(user) {
    const cart = this.carts.get(user) ?? [];
    return cart.length ? cart.join(", ") : "(empty)";
  }
}

// Stateful: each copy keeps carts in its own memory.
const stateful = [new Server(new Map()), new Server(new Map())];
// Stateless: the copies keep nothing; both use one shared store (think: a database).
const shared = new Map();
const stateless = [new Server(shared), new Server(shared)];

const steps = [
  ["add", "tea", "A"],
  ["add", "cake", "B"],
  ["view", "", "A"],
  ["view", "", "B"],
  ["restart", "", "A"],
  ["view", "", "A"],
];
const row = (a, b, c, d) => console.log(`${a.padEnd(10)} ${b.padEnd(4)} ${c.padEnd(26)} ${d}`);
row("request", "copy", "stateful (own memory)", "stateless (shared store)");
for (const [action, item, copy] of steps) {
  const i = "AB".indexOf(copy); // the load balancer sent this request to copy A or B
  if (action === "add") {
    stateful[i].add("alice", item);
    stateless[i].add("alice", item);
  } else if (action === "restart") {
    stateful[i] = new Server(new Map()); // a fresh process starts with empty memory
    stateless[i] = new Server(shared); // ...but it reconnects to the same shared store
    row("restart", copy, "memory wiped", "nothing lost");
    continue;
  }
  row(`${action} ${item}`.trim(), copy, stateful[i].view("alice"), stateless[i].view("alice"));
}

use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;

// A store maps a user to their cart. Each server copy can have its own, or share one.
type Store = Rc<RefCell<HashMap<String, Vec<String>>>>;

fn new_store() -> Store {
    Rc::new(RefCell::new(HashMap::new()))
}

// Server is one running copy of the backend. It only knows the store it was given.
struct Server {
    carts: Store,
}

impl Server {
    fn add(&self, user: &str, item: &str) {
        self.carts.borrow_mut().entry(user.into()).or_default().push(item.into());
    }
    fn view(&self, user: &str) -> String {
        match self.carts.borrow().get(user) {
            Some(cart) if !cart.is_empty() => cart.join(", "),
            _ => "(empty)".into(),
        }
    }
}

fn main() {
    // Stateful: each copy keeps carts in its own memory.
    let mut stateful = vec![Server { carts: new_store() }, Server { carts: new_store() }];
    // Stateless: the copies keep nothing; both use one shared store (think: a database).
    let shared = new_store();
    let mut stateless = vec![Server { carts: shared.clone() }, Server { carts: shared.clone() }];

    let steps = [
        ("add", "tea", "A"),
        ("add", "cake", "B"),
        ("view", "", "A"),
        ("view", "", "B"),
        ("restart", "", "A"),
        ("view", "", "A"),
    ];
    println!("{:<10} {:<4} {:<26} stateless (shared store)", "request", "copy", "stateful (own memory)");
    for (action, item, copy) in steps {
        let i = "AB".find(copy).unwrap(); // the load balancer sent this request to copy A or B
        match action {
            "add" => {
                stateful[i].add("alice", item);
                stateless[i].add("alice", item);
            }
            "restart" => {
                stateful[i] = Server { carts: new_store() }; // a fresh process starts with empty memory
                stateless[i] = Server { carts: shared.clone() }; // ...but it reconnects to the same shared store
                println!("{:<10} {:<4} {:<26} nothing lost", "restart", copy, "memory wiped");
                continue;
            }
            _ => {}
        }
        let label = format!("{action} {item}");
        println!("{:<10} {:<4} {:<26} {}", label.trim(), copy, stateful[i].view("alice"), stateless[i].view("alice"));
    }
}

class Server:
    """One running copy of the backend. It only knows the store it was given:
    a dict from a user to their cart. Each copy can have its own store, or share one."""

    def __init__(self, carts):
        self.carts = carts

    def add(self, user, item):
        self.carts.setdefault(user, []).append(item)

    def view(self, user):
        return ", ".join(self.carts.get(user, [])) or "(empty)"


# Stateful: each copy keeps carts in its own memory.
stateful = [Server({}), Server({})]
# Stateless: the copies keep nothing; both use one shared store (think: a database).
shared = {}
stateless = [Server(shared), Server(shared)]

steps = [
    ("add", "tea", "A"),
    ("add", "cake", "B"),
    ("view", "", "A"),
    ("view", "", "B"),
    ("restart", "", "A"),
    ("view", "", "A"),
]
print(f"{'request':<10} {'copy':<4} {'stateful (own memory)':<26} stateless (shared store)")
for action, item, copy in steps:
    i = "AB".index(copy)  # the load balancer sent this request to copy A or B
    if action == "add":
        stateful[i].add("alice", item)
        stateless[i].add("alice", item)
    elif action == "restart":
        stateful[i] = Server({})  # a fresh process starts with empty memory
        stateless[i] = Server(shared)  # ...but it reconnects to the same shared store
        print(f"{'restart':<10} {copy:<4} {'memory wiped':<26} nothing lost")
        continue
    label = f"{action} {item}".strip()
    print(f"{label:<10} {copy:<4} {stateful[i].view('alice'):<26} {stateless[i].view('alice')}")

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    // A server is one running copy of the backend. It only knows the store it was given:
    // a map from a user to their cart. Each copy can have its own store, or share one.
    record Server(Map<String, List<String>> carts) {
        void add(String user, String item) {
            carts.computeIfAbsent(user, u -> new ArrayList<>()).add(item);
        }

        String view(String user) {
            List<String> cart = carts.getOrDefault(user, List.of());
            return cart.isEmpty() ? "(empty)" : String.join(", ", cart);
        }
    }

    public static void main(String[] args) {
        // Stateful: each copy keeps carts in its own memory.
        Server[] stateful = {new Server(new HashMap<>()), new Server(new HashMap<>())};
        // Stateless: the copies keep nothing; both use one shared store (think: a database).
        Map<String, List<String>> shared = new HashMap<>();
        Server[] stateless = {new Server(shared), new Server(shared)};

        String[][] steps = {
            {"add", "tea", "A"},
            {"add", "cake", "B"},
            {"view", "", "A"},
            {"view", "", "B"},
            {"restart", "", "A"},
            {"view", "", "A"},
        };
        String row = "%-10s %-4s %-26s %s%n";
        System.out.printf(row, "request", "copy", "stateful (own memory)", "stateless (shared store)");
        for (String[] st : steps) {
            int i = "AB".indexOf(st[2]); // the load balancer sent this request to copy A or B
            if (st[0].equals("add")) {
                stateful[i].add("alice", st[1]);
                stateless[i].add("alice", st[1]);
            } else if (st[0].equals("restart")) {
                stateful[i] = new Server(new HashMap<>()); // a fresh process starts with empty memory
                stateless[i] = new Server(shared); // ...but it reconnects to the same shared store
                System.out.printf(row, "restart", st[2], "memory wiped", "nothing lost");
                continue;
            }
            System.out.printf(row, (st[0] + " " + st[1]).trim(), st[2], stateful[i].view("alice"), stateless[i].view("alice"));
        }
    }
}