What Is a Backend System?

package main

import (
	"fmt"
	"strings"
)

const freeLimit = 3 // the free plan keeps at most 3 notes

// The backend's memory: who each token belongs to, and everyone's notes.
var (
	tokens = map[string]string{"t-alice": "alice", "t-bob": "bob"}
	notes  = map[string][]string{}
)

// handle is the whole backend: one request in, one response out.
// It returns the status, the reply, and which of the four jobs had the final say.
func handle(token, action, text string) (int, string, string) {
	user, ok := tokens[token] // protect: who is asking?
	if !ok {
		return 401, "who are you?", "protect"
	}
	switch action {
	case "add":
		if len(notes[user]) >= freeLimit { // decide: is this allowed?
			return 403, fmt.Sprintf("free plan keeps %d notes", freeLimit), "decide"
		}
		words := len(strings.Fields(text))      // compute: work something out
		notes[user] = append(notes[user], text) // store: remember it for next time
		return 201, fmt.Sprintf("saved note %d (%d words)", len(notes[user]), words), "store"
	case "list":
		total := 0
		for _, n := range notes[user] { // compute over what was stored
			total += len(strings.Fields(n))
		}
		return 200, fmt.Sprintf("%d notes, %d words", len(notes[user]), total), "compute"
	}
	return 400, "unknown action", "decide"
}

func main() {
	requests := [][3]string{
		{"", "add", "buy milk"},
		{"t-alice", "add", "buy milk"},
		{"t-alice", "add", "call mom tonight"},
		{"t-alice", "add", "fix the bike"},
		{"t-alice", "add", "learn go"},
		{"t-bob", "list", ""},
		{"t-alice", "list", ""},
		{"t-eve", "list", ""},
	}
	fmt.Printf("%-8s %-5s %-17s %-6s %-26s %s\n", "token", "do", "text", "status", "reply", "job")
	for _, r := range requests {
		status, reply, job := handle(r[0], r[1], r[2])
		token := r[0]
		if token == "" {
			token = "(none)"
		}
		fmt.Printf("%-8s %-5s %-17s %-6d %-26s %s\n", token, r[1], r[2], status, reply, job)
	}
}

const FREE_LIMIT = 3; // the free plan keeps at most 3 notes

// The backend's memory: who each token belongs to, and everyone's notes.
const tokens = { "t-alice": "alice", "t-bob": "bob" };
const notes = {};

const words = (text) => text.split(/\s+/).filter(Boolean).length;

// handle is the whole backend: one request in, one response out.
// It returns the status, the reply, and which of the four jobs had the final say.
function handle(token, action, text) {
  const user = tokens[token]; // protect: who is asking?
  if (!user) return [401, "who are you?", "protect"];
  const mine = (notes[user] ??= []);
  if (action === "add") {
    if (mine.length >= FREE_LIMIT) return [403, `free plan keeps ${FREE_LIMIT} notes`, "decide"]; // decide: is this allowed?
    const count = words(text); // compute: work something out
    mine.push(text); // store: remember it for next time
    return [201, `saved note ${mine.length} (${count} words)`, "store"];
  }
  if (action === "list") {
    const total = mine.reduce((sum, n) => sum + words(n), 0); // compute over what was stored
    return [200, `${mine.length} notes, ${total} words`, "compute"];
  }
  return [400, "unknown action", "decide"];
}

const requests = [
  ["", "add", "buy milk"],
  ["t-alice", "add", "buy milk"],
  ["t-alice", "add", "call mom tonight"],
  ["t-alice", "add", "fix the bike"],
  ["t-alice", "add", "learn go"],
  ["t-bob", "list", ""],
  ["t-alice", "list", ""],
  ["t-eve", "list", ""],
];
const row = (a, b, c, d, e, f) => `${a.padEnd(8)} ${b.padEnd(5)} ${c.padEnd(17)} ${String(d).padEnd(6)} ${e.padEnd(26)} ${f}`;
console.log(row("token", "do", "text", "status", "reply", "job"));
for (const [token, action, text] of requests) {
  const [status, reply, job] = handle(token, action, text);
  console.log(row(token || "(none)", action, text, status, reply, job));
}

use std::collections::HashMap;

const FREE_LIMIT: usize = 3; // the free plan keeps at most 3 notes

// The backend's memory: who each token belongs to, and everyone's notes.
struct Backend {
    tokens: HashMap<&'static str, &'static str>,
    notes: HashMap<&'static str, Vec<String>>,
}

impl Backend {
    // handle is the whole backend: one request in, one response out.
    // It returns the status, the reply, and which of the four jobs had the final say.
    fn handle(&mut self, token: &str, action: &str, text: &str) -> (u16, String, &'static str) {
        let Some(&user) = self.tokens.get(token) else {
            return (401, "who are you?".into(), "protect"); // protect: who is asking?
        };
        let mine = self.notes.entry(user).or_default();
        match action {
            "add" => {
                if mine.len() >= FREE_LIMIT {
                    return (403, format!("free plan keeps {FREE_LIMIT} notes"), "decide"); // decide: is this allowed?
                }
                let words = text.split_whitespace().count(); // compute: work something out
                mine.push(text.to_string()); // store: remember it for next time
                (201, format!("saved note {} ({words} words)", mine.len()), "store")
            }
            "list" => {
                let total: usize = mine.iter().map(|n| n.split_whitespace().count()).sum(); // compute over what was stored
                (200, format!("{} notes, {total} words", mine.len()), "compute")
            }
            _ => (400, "unknown action".into(), "decide"),
        }
    }
}

fn main() {
    let mut backend = Backend {
        tokens: HashMap::from([("t-alice", "alice"), ("t-bob", "bob")]),
        notes: HashMap::new(),
    };
    let requests = [
        ("", "add", "buy milk"),
        ("t-alice", "add", "buy milk"),
        ("t-alice", "add", "call mom tonight"),
        ("t-alice", "add", "fix the bike"),
        ("t-alice", "add", "learn go"),
        ("t-bob", "list", ""),
        ("t-alice", "list", ""),
        ("t-eve", "list", ""),
    ];
    println!("{:<8} {:<5} {:<17} {:<6} {:<26} job", "token", "do", "text", "status", "reply");
    for (token, action, text) in requests {
        let (status, reply, job) = backend.handle(token, action, text);
        let shown = if token.is_empty() { "(none)" } else { token };
        println!("{:<8} {:<5} {:<17} {:<6} {:<26} {}", shown, action, text, status, reply, job);
    }
}

FREE_LIMIT = 3  # the free plan keeps at most 3 notes

# The backend's memory: who each token belongs to, and everyone's notes.
tokens = {"t-alice": "alice", "t-bob": "bob"}
notes = {}


def handle(token, action, text):
    """The whole backend: one request in, one response out.
    Returns the status, the reply, and which of the four jobs had the final say."""
    user = tokens.get(token)  # protect: who is asking?
    if user is None:
        return 401, "who are you?", "protect"
    mine = notes.setdefault(user, [])
    if action == "add":
        if len(mine) >= FREE_LIMIT:  # decide: is this allowed?
            return 403, f"free plan keeps {FREE_LIMIT} notes", "decide"
        words = len(text.split())  # compute: work something out
        mine.append(text)  # store: remember it for next time
        return 201, f"saved note {len(mine)} ({words} words)", "store"
    if action == "list":
        total = sum(len(n.split()) for n in mine)  # compute over what was stored
        return 200, f"{len(mine)} notes, {total} words", "compute"
    return 400, "unknown action", "decide"


requests = [
    ("", "add", "buy milk"),
    ("t-alice", "add", "buy milk"),
    ("t-alice", "add", "call mom tonight"),
    ("t-alice", "add", "fix the bike"),
    ("t-alice", "add", "learn go"),
    ("t-bob", "list", ""),
    ("t-alice", "list", ""),
    ("t-eve", "list", ""),
]
print(f"{'token':<8} {'do':<5} {'text':<17} {'status':<6} {'reply':<26} job")
for token, action, text in requests:
    status, reply, job = handle(token, action, text)
    print(f"{token or '(none)':<8} {action:<5} {text:<17} {status:<6} {reply:<26} {job}")

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

public class Main {
    static final int FREE_LIMIT = 3; // the free plan keeps at most 3 notes

    // The backend's memory: who each token belongs to, and everyone's notes.
    static final Map<String, String> TOKENS = Map.of("t-alice", "alice", "t-bob", "bob");
    static final Map<String, List<String>> NOTES = new HashMap<>();

    record Response(int status, String reply, String job) {}

    static int words(String text) {
        return text.isBlank() ? 0 : text.trim().split("\\s+").length;
    }

    // handle is the whole backend: one request in, one response out.
    // It returns the status, the reply, and which of the four jobs had the final say.
    static Response handle(String token, String action, String text) {
        String user = TOKENS.get(token); // protect: who is asking?
        if (user == null) return new Response(401, "who are you?", "protect");
        List<String> mine = NOTES.computeIfAbsent(user, u -> new ArrayList<>());
        switch (action) {
            case "add" -> {
                if (mine.size() >= FREE_LIMIT) // decide: is this allowed?
                    return new Response(403, "free plan keeps " + FREE_LIMIT + " notes", "decide");
                int count = words(text); // compute: work something out
                mine.add(text); // store: remember it for next time
                return new Response(201, "saved note " + mine.size() + " (" + count + " words)", "store");
            }
            case "list" -> {
                int total = mine.stream().mapToInt(Main::words).sum(); // compute over what was stored
                return new Response(200, mine.size() + " notes, " + total + " words", "compute");
            }
            default -> {
                return new Response(400, "unknown action", "decide");
            }
        }
    }

    public static void main(String[] args) {
        String[][] requests = {
            {"", "add", "buy milk"},
            {"t-alice", "add", "buy milk"},
            {"t-alice", "add", "call mom tonight"},
            {"t-alice", "add", "fix the bike"},
            {"t-alice", "add", "learn go"},
            {"t-bob", "list", ""},
            {"t-alice", "list", ""},
            {"t-eve", "list", ""},
        };
        String row = "%-8s %-5s %-17s %-6s %-26s %s%n";
        System.out.printf(row, "token", "do", "text", "status", "reply", "job");
        for (String[] r : requests) {
            Response res = handle(r[0], r[1], r[2]);
            System.out.printf(row, r[0].isEmpty() ? "(none)" : r[0], r[1], r[2], res.status(), res.reply(), res.job());
        }
    }
}