Design a chat app like WhatsApp: delivery

Python 3.14 · main.py

class Chat:
    def __init__(self) -> None:
        self.log: list[str] = []
        self.seq_of: dict[str, int] = {}

    def send(self, client_id: str, text: str) -> int:
        if client_id in self.seq_of:  # a retry: the same answer, no second copy
            return self.seq_of[client_id]
        self.log.append(text)  # stored before anything is pushed
        self.seq_of[client_id] = len(self.log)
        return len(self.log)


class Device:
    def __init__(self) -> None:
        self.cursor = 0  # the highest seq shown, nothing missing below it
        self.shown: list[str] = []

    def on_push(self, store: Chat, seq: int, text: str) -> str:
        if seq <= self.cursor:
            return "a repeat, ignored"
        if seq == self.cursor + 1:
            self.shown.append(text)
            self.cursor = seq
            return "shown"
        first = self.cursor + 1  # a gap: fetch the rest from the store
        self.shown += store.log[self.cursor :]
        self.cursor = len(store.log)
        return f"gap, fetched {first} to {self.cursor}"


# a2's ack is lost, and so is the push of seq 2
SENDS = [("a1", "hi"), ("a2", "lunch?"), ("a2", "lunch?"), ("a3", "at 1")]
PUSHES = [(1, "hi"), (3, "at 1"), (3, "at 1")]

chat = Chat()
for client_id, text in SENDS:
    seq = chat.send(client_id, text)
    print(f"send {client_id}: seq {seq}, {len(chat.log)} stored")
laptop = Device()
for seq, text in PUSHES:
    result = laptop.on_push(chat, seq, text)
    print(f"push seq {seq}: {result}, cursor {laptop.cursor}")
print(f"laptop shows: {', '.join(laptop.shown)}")

In Python: store.log[self.cursor :] is the slice after the cursor, exactly what a gap leaves missing, because seq n sits at position n - 1 of the log; the space before the colon is how ruff formats a slice bound that is an expression.

Recorded with CPython 3.14.8 on macOS 26 arm64. It runs in your browser with Pyodide 314.0.7 (CPython 3.14.2). To run it yourself: python3 main.py

JavaScript Node 24 · main.mjs

class Chat {
  log = [];
  #seqOf = new Map();

  send(clientId, text) {
    if (this.#seqOf.has(clientId)) {
      return this.#seqOf.get(clientId); // a retry: the same answer, no second copy
    }
    this.log.push(text); // stored before anything is pushed
    this.#seqOf.set(clientId, this.log.length);
    return this.log.length;
  }
}

class Device {
  cursor = 0; // the highest seq shown, nothing missing below it
  shown = [];

  onPush(store, seq, text) {
    if (seq <= this.cursor) {
      return "a repeat, ignored";
    }
    if (seq === this.cursor + 1) {
      this.shown.push(text);
      this.cursor = seq;
      return "shown";
    }
    const first = this.cursor + 1; // a gap: fetch the rest from the store
    this.shown.push(...store.log.slice(this.cursor));
    this.cursor = store.log.length;
    return `gap, fetched ${first} to ${this.cursor}`;
  }
}

// a2's ack is lost, and so is the push of seq 2
const sends = [
  ["a1", "hi"],
  ["a2", "lunch?"],
  ["a2", "lunch?"],
  ["a3", "at 1"],
];
const pushes = [
  [1, "hi"],
  [3, "at 1"],
  [3, "at 1"],
];

const chat = new Chat();
for (const [clientId, text] of sends) {
  const seq = chat.send(clientId, text);
  console.log(`send ${clientId}: seq ${seq}, ${chat.log.length} stored`);
}
const laptop = new Device();
for (const [seq, text] of pushes) {
  const result = laptop.onPush(chat, seq, text);
  console.log(`push seq ${seq}: ${result}, cursor ${laptop.cursor}`);
}
console.log(`laptop shows: ${laptop.shown.join(", ")}`);

In JavaScript: #seqOf is a private field, so only Chat reads the client ids, and push(...store.log.slice(this.cursor)) appends the fetched messages one by one.

Recorded with Node.js 24.21.0 LTS (V8 13.6) on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0). To run it yourself: node main.mjs

Java 25 LTS · Main.java

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

public class Main {
  static final class Chat {
    final List<String> log = new ArrayList<>();
    private final Map<String, Integer> seqOf = new HashMap<>();

    int send(String clientId, String text) {
      Integer known = seqOf.get(clientId);
      if (known != null) {
        return known; // a retry: the same answer, no second copy
      }
      log.add(text); // stored before anything is pushed
      seqOf.put(clientId, log.size());
      return log.size();
    }
  }

  static final class Device {
    int cursor = 0; // the highest seq shown, nothing missing below it
    final List<String> shown = new ArrayList<>();

    String onPush(Chat store, int seq, String text) {
      if (seq <= cursor) {
        return "a repeat, ignored";
      }
      if (seq == cursor + 1) {
        shown.add(text);
        cursor = seq;
        return "shown";
      }
      int first = cursor + 1; // a gap: fetch the rest from the store
      shown.addAll(store.log.subList(cursor, store.log.size()));
      cursor = store.log.size();
      return "gap, fetched " + first + " to " + cursor;
    }
  }

  record Push(int seq, String text) {}

  public static void main(String[] args) {
    // a2's ack is lost, and so is the push of seq 2
    String[][] sends = {{"a1", "hi"}, {"a2", "lunch?"}, {"a2", "lunch?"}, {"a3", "at 1"}};
    List<Push> pushes = List.of(new Push(1, "hi"), new Push(3, "at 1"), new Push(3, "at 1"));
    var chat = new Chat();
    for (String[] send : sends) {
      int seq = chat.send(send[0], send[1]);
      System.out.println("send " + send[0] + ": seq " + seq + ", " + chat.log.size() + " stored");
    }
    var laptop = new Device();
    for (Push push : pushes) {
      String result = laptop.onPush(chat, push.seq(), push.text());
      System.out.println("push seq " + push.seq() + ": " + result + ", cursor " + laptop.cursor);
    }
    System.out.println("laptop shows: " + String.join(", ", laptop.shown));
  }
}

In Java: subList(cursor, size) is a view of the log after the cursor and addAll copies it; a Push is a record, Java's class for a small value.

Recorded with OpenJDK 25.0.4.1 LTS (Eclipse Temurin) on macOS 26 arm64. It runs in your browser with a TeaVM 0.16.0 build in QuickJS (quickjs-emscripten 0.32.0). To run it yourself: java Main.java

C++23 · main.cpp

#include <format>
#include <map>
#include <print>
#include <string>
#include <utility>
#include <vector>

class Chat {
  std::map<std::string, int> seqOf;

public:
  std::vector<std::string> log;

  int send(const std::string &clientId, const std::string &text) {
    if (const auto known = seqOf.find(clientId); known != seqOf.end()) {
      return known->second; // a retry: the same answer, no second copy
    }
    log.push_back(text); // stored before anything is pushed
    return seqOf[clientId] = static_cast<int>(log.size());
  }
};

struct Device {
  int cursor = 0; // the highest seq shown, nothing missing below it
  std::vector<std::string> shown;

  std::string onPush(const Chat &store, int seq, std::string text) {
    if (seq <= cursor) {
      return "a repeat, ignored";
    }
    if (seq == cursor + 1) {
      shown.push_back(std::move(text));
      cursor = seq;
      return "shown";
    }
    const int first = cursor + 1; // a gap: fetch the rest from the store
    shown.insert(shown.end(), store.log.begin() + cursor, store.log.end());
    cursor = static_cast<int>(store.log.size());
    return std::format("gap, fetched {} to {}", first, cursor);
  }
};

int main() {
  // a2's ack is lost, and so is the push of seq 2
  const std::vector<std::pair<std::string, std::string>> sends = {
      {"a1", "hi"}, {"a2", "lunch?"}, {"a2", "lunch?"}, {"a3", "at 1"}};
  const std::vector<std::pair<int, std::string>> pushes = {
      {1, "hi"}, {3, "at 1"}, {3, "at 1"}};
  Chat chat;
  for (const auto &[clientId, text] : sends) {
    const int seq = chat.send(clientId, text);
    std::println("send {}: seq {}, {} stored", clientId, seq, chat.log.size());
  }
  Device laptop;
  for (const auto &[seq, text] : pushes) {
    const std::string result = laptop.onPush(chat, seq, text);
    std::println("push seq {}: {}, cursor {}", seq, result, laptop.cursor);
  }
  std::println("laptop shows: {:n:}", laptop.shown);
}

In C++: find in the if statement's initializer looks a retry up once, and the {:n:} format of C++23 prints a vector of strings without brackets or quotes: hi, lunch?, at 1.

Recorded with Apple clang 21.0.0 (C++23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang++ -std=c++23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.cpp -o main && ./main

C# 14 · .NET 10 · app.cs

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

// a2's ack is lost, and so is the push of seq 2
(string ClientId, string Text)[] sends =
    [("a1", "hi"), ("a2", "lunch?"), ("a2", "lunch?"), ("a3", "at 1")];
(int Seq, string Text)[] pushes = [(1, "hi"), (3, "at 1"), (3, "at 1")];

var chat = new Chat();
foreach (var (clientId, text) in sends)
{
    int seq = chat.Send(clientId, text);
    Console.WriteLine($"send {clientId}: seq {seq}, {chat.Log.Count} stored");
}
var laptop = new Device();
foreach (var (seq, text) in pushes)
{
    string result = laptop.OnPush(chat, seq, text);
    Console.WriteLine($"push seq {seq}: {result}, cursor {laptop.Cursor}");
}
Console.WriteLine($"laptop shows: {string.Join(", ", laptop.Shown)}");

sealed class Chat
{
    public List<string> Log { get; } = [];
    private readonly Dictionary<string, int> seqOf = new();

    public int Send(string clientId, string text)
    {
        if (seqOf.TryGetValue(clientId, out int known))
        {
            return known; // a retry: the same answer, no second copy
        }
        Log.Add(text); // stored before anything is pushed
        seqOf[clientId] = Log.Count;
        return Log.Count;
    }
}

sealed class Device
{
    public int Cursor { get; private set; } // the highest seq shown, nothing missing below it
    public List<string> Shown { get; } = [];

    public string OnPush(Chat store, int seq, string text)
    {
        if (seq <= Cursor)
        {
            return "a repeat, ignored";
        }
        if (seq == Cursor + 1)
        {
            Shown.Add(text);
            Cursor = seq;
            return "shown";
        }
        int first = Cursor + 1; // a gap: fetch the rest from the store
        Shown.AddRange(store.Log.Skip(Cursor));
        Cursor = store.Log.Count;
        return $"gap, fetched {first} to {Cursor}";
    }
}

In C#: TryGetValue looks a retry up once, Skip(Cursor) is the LINQ slice after the cursor, and the sends and pushes are arrays of named tuples.

Recorded with C# 14 on .NET 10.0.12 (SDK 10.0.401) on macOS 26 arm64. It runs in your browser with the .NET runtime for WebAssembly 10.0.12. To run it yourself: dotnet run app.cs

C23 · main.c

#include <stdio.h>
#include <string.h>

enum { MAX_MESSAGES = 8 };

typedef struct {
  const char *log[MAX_MESSAGES];
  const char *ids[MAX_MESSAGES];
  int count;
} Chat;

static int chat_send(Chat *chat, const char *id, const char *text) {
  for (int i = 0; i < chat->count; i++) {
    if (strcmp(chat->ids[i], id) == 0) {
      return i + 1; // a retry: the same answer, no second copy
    }
  }
  chat->log[chat->count] = text; // stored before anything is pushed
  chat->ids[chat->count] = id;
  return ++chat->count;
}

typedef struct {
  int cursor; // the highest seq shown, nothing missing below it
  const char *shown[MAX_MESSAGES];
} Device;

static const char *on_push(Device *device, const Chat *store, int seq,
                           const char *text, char gap[static 48]) {
  if (seq <= device->cursor) {
    return "a repeat, ignored";
  }
  if (seq == device->cursor + 1) {
    device->shown[device->cursor++] = text;
    return "shown";
  }
  const int first = device->cursor + 1; // a gap: fetch the rest from the store
  for (; device->cursor < store->count; device->cursor++) {
    device->shown[device->cursor] = store->log[device->cursor];
  }
  snprintf(gap, 48, "gap, fetched %d to %d", first, device->cursor);
  return gap;
}

int main(void) {
  // a2's ack is lost, and so is the push of seq 2
  static const char *const sends[][2] = {
      {"a1", "hi"}, {"a2", "lunch?"}, {"a2", "lunch?"}, {"a3", "at 1"}};
  static const int seqs[] = {1, 3, 3};
  static const char *const texts[] = {"hi", "at 1", "at 1"};
  Chat chat = {0};
  for (size_t i = 0; i < sizeof sends / sizeof sends[0]; i++) {
    const int seq = chat_send(&chat, sends[i][0], sends[i][1]);
    printf("send %s: seq %d, %d stored\n", sends[i][0], seq, chat.count);
  }
  Device laptop = {0};
  for (size_t i = 0; i < sizeof seqs / sizeof seqs[0]; i++) {
    char gap[48];
    const char *result = on_push(&laptop, &chat, seqs[i], texts[i], gap);
    printf("push seq %d: %s, cursor %d\n", seqs[i], result, laptop.cursor);
  }
  printf("laptop shows:");
  for (int i = 0; i < laptop.cursor; i++)
    printf("%s %s", i ? "," : "", laptop.shown[i]);
  printf("\n");
  return 0;
}

In C: C has no map, so the client id of seq n is kept at ids[n - 1] and a retry is found by a scan with strcmp; the device's cursor doubles as the count of what it shows.

Recorded with Apple clang 21.0.0 (C23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang -std=c23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.c -o main && ./main

PHP 8.5 · main.php

<?php

declare(strict_types=1);

final class Chat
{
    /** @var list<string> */
    public array $log = [];
    /** @var array<string, int> */
    private array $seqOf = [];

    public function send(string $clientId, string $text): int
    {
        if (isset($this->seqOf[$clientId])) {
            return $this->seqOf[$clientId]; // a retry: the same answer, no second copy
        }
        $this->log[] = $text; // stored before anything is pushed
        $this->seqOf[$clientId] = count($this->log);
        return count($this->log);
    }
}

final class Device
{
    public int $cursor = 0; // the highest seq shown, nothing missing below it
    /** @var list<string> */
    public array $shown = [];

    public function onPush(Chat $store, int $seq, string $text): string
    {
        if ($seq <= $this->cursor) {
            return 'a repeat, ignored';
        }
        if ($seq === $this->cursor + 1) {
            $this->shown[] = $text;
            $this->cursor = $seq;
            return 'shown';
        }
        $first = $this->cursor + 1; // a gap: fetch the rest from the store
        array_push($this->shown, ...array_slice($store->log, $this->cursor));
        $this->cursor = count($store->log);
        return "gap, fetched {$first} to {$this->cursor}";
    }
}

// a2's ack is lost, and so is the push of seq 2
$sends = [['a1', 'hi'], ['a2', 'lunch?'], ['a2', 'lunch?'], ['a3', 'at 1']];
$pushes = [[1, 'hi'], [3, 'at 1'], [3, 'at 1']];

$chat = new Chat();
foreach ($sends as [$clientId, $text]) {
    $seq = $chat->send($clientId, $text);
    echo "send {$clientId}: seq {$seq}, " . count($chat->log) . " stored\n";
}
$laptop = new Device();
foreach ($pushes as [$seq, $text]) {
    $result = $laptop->onPush($chat, $seq, $text);
    echo "push seq {$seq}: {$result}, cursor {$laptop->cursor}\n";
}
echo 'laptop shows: ' . implode(', ', $laptop->shown) . "\n";

In PHP: array_slice($store->log, $this->cursor) is the slice after the cursor, the spread operator appends it in one call, and isset finds a retry without a warning for a missing key.

Recorded with PHP 8.5.11 (CLI) on macOS 26 arm64. It runs in your browser with php-wasm 0.2.0 (PHP 8.5.2). To run it yourself: php main.php

Rust 1.99 · main.rs

use std::collections::HashMap;

#[derive(Default)]
struct Chat {
    log: Vec<String>,
    seq_of: HashMap<String, usize>,
}

impl Chat {
    fn send(&mut self, client_id: &str, text: &str) -> usize {
        if let Some(&seq) = self.seq_of.get(client_id) {
            return seq; // a retry: the same answer, no second copy
        }
        self.log.push(text.to_string()); // stored before anything is pushed
        self.seq_of.insert(client_id.to_string(), self.log.len());
        self.log.len()
    }
}

#[derive(Default)]
struct Device {
    cursor: usize, // the highest seq shown, nothing missing below it
    shown: Vec<String>,
}

impl Device {
    fn on_push(&mut self, store: &Chat, seq: usize, text: &str) -> String {
        if seq <= self.cursor {
            return "a repeat, ignored".to_string();
        }
        if seq == self.cursor + 1 {
            self.shown.push(text.to_string());
            self.cursor = seq;
            return "shown".to_string();
        }
        let first = self.cursor + 1; // a gap: fetch the rest from the store
        self.shown.extend_from_slice(&store.log[self.cursor..]);
        self.cursor = store.log.len();
        format!("gap, fetched {first} to {}", self.cursor)
    }
}

fn main() {
    // a2's ack is lost, and so is the push of seq 2
    let sends = [
        ("a1", "hi"),
        ("a2", "lunch?"),
        ("a2", "lunch?"),
        ("a3", "at 1"),
    ];
    let pushes = [(1, "hi"), (3, "at 1"), (3, "at 1")];
    let mut chat = Chat::default();
    for (client_id, text) in sends {
        let seq = chat.send(client_id, text);
        println!("send {client_id}: seq {seq}, {} stored", chat.log.len());
    }
    let mut laptop = Device::default();
    for (seq, text) in pushes {
        let result = laptop.on_push(&chat, seq, text);
        println!("push seq {seq}: {result}, cursor {}", laptop.cursor);
    }
    println!("laptop shows: {}", laptop.shown.join(", "));
}

In Rust: on_push borrows the chat (&Chat) only for the call, so the store and the device are never borrowed mutably at once; extend_from_slice copies the slice after the cursor.

Recorded with rustc 1.99.0 (edition 2024) on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: rustc --edition 2024 -O main.rs && ./main

TypeScript 6.0 · main.ts

class Chat {
  readonly log: string[] = [];
  readonly #seqOf = new Map<string, number>();

  send(clientId: string, text: string): number {
    const known = this.#seqOf.get(clientId);
    if (known !== undefined) {
      return known; // a retry: the same answer, no second copy
    }
    this.log.push(text); // stored before anything is pushed
    this.#seqOf.set(clientId, this.log.length);
    return this.log.length;
  }
}

class Device {
  cursor = 0; // the highest seq shown, nothing missing below it
  readonly shown: string[] = [];

  onPush(store: Chat, seq: number, text: string): string {
    if (seq <= this.cursor) {
      return "a repeat, ignored";
    }
    if (seq === this.cursor + 1) {
      this.shown.push(text);
      this.cursor = seq;
      return "shown";
    }
    const first = this.cursor + 1; // a gap: fetch the rest from the store
    this.shown.push(...store.log.slice(this.cursor));
    this.cursor = store.log.length;
    return `gap, fetched ${first} to ${this.cursor}`;
  }
}

// a2's ack is lost, and so is the push of seq 2
const sends: [string, string][] = [
  ["a1", "hi"],
  ["a2", "lunch?"],
  ["a2", "lunch?"],
  ["a3", "at 1"],
];
const pushes: [number, string][] = [
  [1, "hi"],
  [3, "at 1"],
  [3, "at 1"],
];

const chat = new Chat();
for (const [clientId, text] of sends) {
  const seq = chat.send(clientId, text);
  console.log(`send ${clientId}: seq ${seq}, ${chat.log.length} stored`);
}
const laptop = new Device();
for (const [seq, text] of pushes) {
  const result = laptop.onPush(chat, seq, text);
  console.log(`push seq ${seq}: ${result}, cursor ${laptop.cursor}`);
}
console.log(`laptop shows: ${laptop.shown.join(", ")}`);

In TypeScript: #seqOf is a private field of standard JavaScript, so it survives when the types are stripped, and Map.get returns undefined for a new client id, which send checks before it returns.

Recorded with TypeScript 6.0.3 (strict), run by Node.js 24.21.0 on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0) after Sucrase 3.35.1. To run it yourself: npx -p typescript@6.0.3 tsc --noEmit --strict main.ts && node main.ts

Go 1.27 · main.go

package main

import (
	"fmt"
	"strings"
)

type Chat struct {
	log   []string
	seqOf map[string]int
}

func (c *Chat) send(clientID, text string) int {
	if seq, ok := c.seqOf[clientID]; ok {
		return seq // a retry: the same answer, no second copy
	}
	c.log = append(c.log, text) // stored before anything is pushed
	c.seqOf[clientID] = len(c.log)
	return len(c.log)
}

type Device struct {
	cursor int // the highest seq shown, nothing missing below it
	shown  []string
}

func (d *Device) onPush(store *Chat, seq int, text string) string {
	switch {
	case seq <= d.cursor:
		return "a repeat, ignored"
	case seq == d.cursor+1:
		d.shown = append(d.shown, text)
		d.cursor = seq
		return "shown"
	}
	first := d.cursor + 1 // a gap: fetch the rest from the store
	d.shown = append(d.shown, store.log[d.cursor:]...)
	d.cursor = len(store.log)
	return fmt.Sprintf("gap, fetched %d to %d", first, d.cursor)
}

func main() {
	// a2's ack is lost, and so is the push of seq 2
	sends := [][2]string{{"a1", "hi"}, {"a2", "lunch?"}, {"a2", "lunch?"}, {"a3", "at 1"}}
	pushes := []struct {
		seq  int
		text string
	}{{1, "hi"}, {3, "at 1"}, {3, "at 1"}}
	chat := &Chat{seqOf: map[string]int{}}
	for _, send := range sends {
		seq := chat.send(send[0], send[1])
		fmt.Printf("send %s: seq %d, %d stored\n", send[0], seq, len(chat.log))
	}
	laptop := &Device{}
	for _, push := range pushes {
		result := laptop.onPush(chat, push.seq, push.text)
		fmt.Printf("push seq %d: %s, cursor %d\n", push.seq, result, laptop.cursor)
	}
	fmt.Printf("laptop shows: %s\n", strings.Join(laptop.shown, ", "))
}

In Go: A switch with no condition replaces the if chain, append(d.shown, store.log[d.cursor:]...) adds the slice after the cursor, and the map of client ids is made with the chat.

Recorded with Go 1.27.1 on macOS 26 arm64. It runs in your browser with the Go compiler in WebAssembly 1.27.1. To run it yourself: go run main.go

Swift 6.4 · main.swift

struct Chat {
  private(set) var log: [String] = []
  private var seqOf: [String: Int] = [:]

  mutating func send(clientID: String, text: String) -> Int {
    if let known = seqOf[clientID] {
      return known  // a retry: the same answer, no second copy
    }
    log.append(text)  // stored before anything is pushed
    seqOf[clientID] = log.count
    return log.count
  }
}

struct Device {
  private(set) var cursor = 0  // the highest seq shown, nothing missing below it
  private(set) var shown: [String] = []

  mutating func onPush(from store: Chat, seq: Int, text: String) -> String {
    if seq <= cursor {
      return "a repeat, ignored"
    }
    if seq == cursor + 1 {
      shown.append(text)
      cursor = seq
      return "shown"
    }
    let first = cursor + 1  // a gap: fetch the rest from the store
    shown += store.log[cursor...]
    cursor = store.log.count
    return "gap, fetched \(first) to \(cursor)"
  }
}

// a2's ack is lost, and so is the push of seq 2
let sends = [("a1", "hi"), ("a2", "lunch?"), ("a2", "lunch?"), ("a3", "at 1")]
let pushes = [(1, "hi"), (3, "at 1"), (3, "at 1")]

var chat = Chat()
for (clientID, text) in sends {
  let seq = chat.send(clientID: clientID, text: text)
  print("send \(clientID): seq \(seq), \(chat.log.count) stored")
}
var laptop = Device()
for (seq, text) in pushes {
  let result = laptop.onPush(from: chat, seq: seq, text: text)
  print("push seq \(seq): \(result), cursor \(laptop.cursor)")
}
print("laptop shows: \(laptop.shown.joined(separator: ", "))")

In Swift: Chat and Device are structs, so onPush(from:) receives a copy of the store and send is a mutating method; store.log[cursor...] is the slice after the cursor.

Recorded with Apple Swift 6.4 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: swiftc -O main.swift -o main && ./main

Ruby 4.0 · main.rb

# frozen_string_literal: true

# Numbers each message, stores it and answers retries.
class Chat
  attr_reader :log

  def initialize
    @log = []
    @seq_of = {}
  end

  def send_message(client_id, text)
    return @seq_of[client_id] if @seq_of.key?(client_id) # a retry: the same answer, no second copy

    @log << text # stored before anything is pushed
    @seq_of[client_id] = @log.size
  end
end

# Shows messages in seq order, each once.
class Device
  attr_reader :cursor, :shown

  def initialize
    @cursor = 0 # the highest seq shown, nothing missing below it
    @shown = []
  end

  def on_push(store, seq, text)
    return 'a repeat, ignored' if seq <= @cursor

    if seq == @cursor + 1
      @shown << text
      @cursor = seq
      return 'shown'
    end
    first = @cursor + 1 # a gap: fetch the rest from the store
    @shown.concat(store.log[@cursor..])
    @cursor = store.log.size
    "gap, fetched #{first} to #{@cursor}"
  end
end

# a2's ack is lost, and so is the push of seq 2
SENDS = [%w[a1 hi], %w[a2 lunch?], %w[a2 lunch?], ['a3', 'at 1']].freeze
PUSHES = [[1, 'hi'], [3, 'at 1'], [3, 'at 1']].freeze

chat = Chat.new
SENDS.each do |client_id, text|
  seq = chat.send_message(client_id, text)
  puts "send #{client_id}: seq #{seq}, #{chat.log.size} stored"
end
laptop = Device.new
PUSHES.each do |seq, text|
  result = laptop.on_push(chat, seq, text)
  puts "push seq #{seq}: #{result}, cursor #{laptop.cursor}"
end
puts "laptop shows: #{laptop.shown.join(', ')}"

In Ruby: send would replace Object#send, which every Ruby object has, so the method is send_message, and it ends with an assignment, whose value is the new seq. RuboCop asks for a comment above each class.

Recorded with CRuby 4.0.7 on macOS 26 arm64. It runs in your browser with ruby.wasm 2.10.1 (Ruby 4.0.0). To run it yourself: ruby main.rb

Kotlin 2.4 · Main.kt

class Chat {
    val log = mutableListOf<String>()
    private val seqOf = mutableMapOf<String, Int>()

    fun send(
        clientId: String,
        text: String,
    ): Int {
        seqOf[clientId]?.let { return it } // a retry: the same answer, no second copy
        log.add(text) // stored before anything is pushed
        seqOf[clientId] = log.size
        return log.size
    }
}

class Device {
    var cursor = 0 // the highest seq shown, nothing missing below it
        private set
    val shown = mutableListOf<String>()

    fun onPush(
        store: Chat,
        seq: Int,
        text: String,
    ): String {
        if (seq <= cursor) return "a repeat, ignored"
        if (seq == cursor + 1) {
            shown.add(text)
            cursor = seq
            return "shown"
        }
        val first = cursor + 1 // a gap: fetch the rest from the store
        shown.addAll(store.log.drop(cursor))
        cursor = store.log.size
        return "gap, fetched $first to $cursor"
    }
}

fun main() {
    // a2's ack is lost, and so is the push of seq 2
    val sends = listOf("a1" to "hi", "a2" to "lunch?", "a2" to "lunch?", "a3" to "at 1")
    val pushes = listOf(1 to "hi", 3 to "at 1", 3 to "at 1")
    val chat = Chat()
    for ((clientId, text) in sends) {
        val seq = chat.send(clientId, text)
        println("send $clientId: seq $seq, ${chat.log.size} stored")
    }
    val laptop = Device()
    for ((seq, text) in pushes) {
        val result = laptop.onPush(chat, seq, text)
        println("push seq $seq: $result, cursor ${laptop.cursor}")
    }
    println("laptop shows: ${laptop.shown.joinToString(", ")}")
}

In Kotlin: seqOf[clientId]?.let { return it } answers a retry in one line, drop(cursor) gives the messages after the cursor, and cursor has a private setter.

Recorded with Kotlin 2.4.20 on Java 25.0.4.1 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

Dart 3.13 · main.dart

class Chat {
  final List<String> log = [];
  final Map<String, int> _seqOf = {};

  int send(String clientId, String text) {
    final known = _seqOf[clientId];
    if (known != null) {
      return known; // a retry: the same answer, no second copy
    }
    log.add(text); // stored before anything is pushed
    _seqOf[clientId] = log.length;
    return log.length;
  }
}

class Device {
  int cursor = 0; // the highest seq shown, nothing missing below it
  final List<String> shown = [];

  String onPush(Chat store, int seq, String text) {
    if (seq <= cursor) {
      return 'a repeat, ignored';
    }
    if (seq == cursor + 1) {
      shown.add(text);
      cursor = seq;
      return 'shown';
    }
    final first = cursor + 1; // a gap: fetch the rest from the store
    shown.addAll(store.log.sublist(cursor));
    cursor = store.log.length;
    return 'gap, fetched $first to $cursor';
  }
}

void main() {
  // a2's ack is lost, and so is the push of seq 2
  final sends = [
    ('a1', 'hi'),
    ('a2', 'lunch?'),
    ('a2', 'lunch?'),
    ('a3', 'at 1'),
  ];
  final pushes = [(1, 'hi'), (3, 'at 1'), (3, 'at 1')];
  final chat = Chat();
  for (final (clientId, text) in sends) {
    final seq = chat.send(clientId, text);
    print('send $clientId: seq $seq, ${chat.log.length} stored');
  }
  final laptop = Device();
  for (final (seq, text) in pushes) {
    final result = laptop.onPush(chat, seq, text);
    print('push seq $seq: $result, cursor ${laptop.cursor}');
  }
  print('laptop shows: ${laptop.shown.join(', ')}');
}

In Dart: sublist(cursor) is the slice after the cursor, and the sends and pushes are records, taken apart by the for-in pattern (clientId, text).

Recorded with Dart 3.13.5 on macOS 26 arm64. It runs in your browser with a WebAssembly build by dart2wasm 3.13.5. To run it yourself: dart run main.dart