uMayBeSeated

A lightweight tool to create wish-based classroom seating plans quickly. Add learners with their wishes and rejections, lay out your room, and let the built-in algorithms propose a seating plan. No server, no account—your data stays in the browser session.

• Live app (static hosting-friendly, e.g., GitHub Pages)
• Framework: Angular

Why uMayBeSeated?

Teachers often collect small slips where students note who they want to sit with and who they should avoid. This tool turns those notes into a seating plan in minutes. You can always fine-tune manually.

Features

• Learners with wishes and rejections (names as free text, easy to correct)
• Two graph-based seat assignment algorithms plus a random baseline
• Visual workspace to place seats with a snapping raster
• Inline highlights of compatible/incompatible neighbors
• Import/Export learners as JSON
• Save and load table arrangements (JSON)
• Built for static hosting (no backend); nothing is stored on a server

Screenshots

Creator workspace and algorithm controls:

Learners management with wishes and rejections:

Quick Start

• Use online (static hosting): open the published page (e.g., GitHub Pages) and start. No signup required.
• Develop locally:

npm install
npm run start

Then open http://localhost:4200

How it works (at a glance)

1. Add learners with “Wishes” and “Rejections”. Names are plain text; confirm each entry with ENTER. If a name isn’t created yet, it’s shown with an asterisk (*) until you add it.
2. Recreate your classroom layout in the Creator by adding seats and dragging them into positions. The sticky raster helps keep alignment—leave it on for best algorithm results.
3. Choose one of the algorithms to compute a seating plan. You can re-run or switch algorithms, then adjust manually via drag & drop.
4. Export your learners list for later reuse. Save room layouts as JSON as well.

Algorithms

• Dislike → Like → Neutral
  • Prioritizes respecting rejections first. Only then tries to fulfill wishes. This usually yields fewer fulfilled wishes but minimizes problematic neighbor pairs.
• Like → Dislike → Neutral
  • Tries to fulfill as many wishes as possible first. Rejections might be harder to guarantee in complex cases.
• Random seating
  • Baseline random assignment.

Tip from the UI tutorial: After generating a plan, wished neighbors are highlighted in green and rejected neighbors in purple when a seat with an assigned learner is selected.

Guided tour (mirrors the in‑app Tutorial)

• Workspace (Creator)

  1. Arrange seats by drag & drop; the controls in the hover area help add/remove seats. Light blue seats indicate at least one fulfilled wish.
  2. Choose preset table arrangements and adjust them to match your room.
  3. Open “Learners” to manage names, wishes, and rejections; open “Tutorial” anytime.
  4. Pick an algorithm to compute a seating plan once seats and learners are ready.
  5. Controls: add many seats at once, toggle raster snapping (recommended ON).
  6. A small info panel summarizes stats depending on learners and the chosen algorithm.

• Learners view

  1. Left side: list of all learners with their wishes/rejections and counters (wished by, rejected by, difference = wishes − rejections). Click any learner to edit. The red bin deletes a learner. A trailing “*” marks names that aren’t yet created as separate entries.
  2. Right side: form to add or edit learners. IMPORTANT: Confirm each wish/rejection with ENTER and write names exactly as they appear (including capitalization) to link them.
  3. Export/import your learner list as JSON, e.g., to continue after reloading the page.

Data privacy

• No server database. Everything lives in the current browser session only.
• Reloading or closing the tab discards the data unless you exported it.
• Always export learners before leaving if you want to continue later.

Import/Export formats

• Learners JSON (example):

{
  "Alice": {
    "wishes": ["Bob"],
    "rejects": ["Eve"]
  },
  "Bob": {
    "wishes": ["Alice"],
    "rejects": []
  }
}

• Table arrangement JSON (example):

{
  "seats": [
    { "id": 1, "x": 0, "y": 0 },
    { "id": 2, "x": 120, "y": 0 },
    { "id": 3, "x": 0, "y": 120 }
  ]
}

You can load built‑in arrangements from the menu or import/export your own.

Tips for best results

• Keep the raster snapping enabled to ensure “neighbor” detection matches the algorithm’s expectations.
• Arrange seats first; add all learners first; run an algorithm; then tweak seats or swap learners with drag & drop.
• Use consistent, correctly spelled names so wishes/rejections link up across entries.

---

uMayBeSeated (Deutsch)

Ein leichtgewichtiges Tool, um schnell wunschbasierte Sitzpläne zu erstellen. Lernende mit Wünschen und Ablehnungen erfassen, den Raum nachbauen und einen Algorithmus den Sitzplan vorschlagen lassen. Kein Server, kein Account – Ihre Daten bleiben in der aktuellen Browsersitzung.

• Live‑App (statisch hostbar, z. B. GitHub Pages)
• Framework: Angular

Warum uMayBeSeated?

Lehrkräfte sammeln oft kleine Zettel, auf denen Lernende notieren, neben wem sie gerne sitzen möchten und wen sie vermeiden sollten. Dieses Tool verwandelt diese Zettel in wenigen Minuten in einen Sitzplan. Manuelle Feinanpassungen sind jederzeit möglich.

Funktionen

• Lernende mit Wünschen und Ablehnungen (Namen als Freitext, leicht korrigierbar)
• Zwei graphbasierte Sitzplatz‑Algorithmen plus eine Zufalls-Variante
• Visuelle Arbeitsfläche mit Raster‑Snapping
• Einfärbung von passenden/unpassenden Nachbarschaften
• Import/Export der Lernenden als JSON
• Speichern/Laden von Tischanordnungen (JSON)
• Für statisches Hosting gebaut (kein Backend); nichts wird serverseitig gespeichert

Screenshots

Creator‑Arbeitsfläche und Algorithmus‑Steuerung:

Lernenden‑Verwaltung mit Wünschen und Ablehnungen:

Schnellstart

• Online nutzen (statisches Hosting): veröffentlichte Seite öffnen (z. B. GitHub Pages) und loslegen. Keine Anmeldung notwendig.
• Lokal entwickeln:

npm install
npm run start

Danach http://localhost:4200 im Browser öffnen.

Funktionsweise (Kurzüberblick)

1. Lernende mit „Wünschen“ und „Ablehnungen“ anlegen. Namen sind Freitext; jeden Eintrag mit ENTER bestätigen. Nicht‑existente Namen werden mit Sternchen (*) markiert, bis sie hinzugefügt werden.
2. Die Klassenraum‑Anordnung im Creator nachbauen: Sitze hinzufügen und per Drag & Drop auf dem Raster positionieren. Raster‑Snapping eingeschaltet lassen (empfohlen) – das verbessert die Ergebnisse.
3. Einen Algorithmus auswählen, um einen Sitzplan zu berechnen. Sie können mehrfach neu berechnen und anschließend manuell per Drag & Drop nachjustieren.
4. Lernendenliste für spätere Nutzung exportieren. Tischanordnungen ebenfalls als JSON speichern.

Algorithmen

• Dislike → Like → Neutral
  • Respektiert zunächst Ablehnungen. Danach werden Wünsche erfüllt. Führt meist zu weniger erfüllten Wünschen, reduziert aber problematische Nachbarschaften.
• Like → Dislike → Neutral
  • Versucht, so viele Wünsche wie möglich zuerst zu erfüllen. Ablehnungen können in komplexen Fällen schwerer zu garantieren sein.
• Zufällige Platzierung
  • Zufalls‑Baseline.

Tipp aus der UI‑Hilfe: Nach der Berechnung werden bei Auswahl eines belegten Sitzes gewünschte Nachbarn grün und abgelehnte Nachbarn lila hervorgehoben.

Geführte Tour (entspricht dem In‑App‑Tutorial)

• Arbeitsfläche (Creator)

  1. Sitze per Drag & Drop anordnen; die Bedienelemente im Hover‑Bereich helfen beim Hinzufügen/Entfernen. Hellblaue Sitze zeigen mindestens einen erfüllten Wunsch.
  2. Vordefinierte Tischanordnungen wählen und anpassen.
  3. „Lernende“ zum Verwalten von Namen/Wünschen/Ablehnungen öffnen; „Tutorial“ jederzeit verfügbar.
  4. Sobald Sitze und Lernende bereit sind, Algorithmus zum Berechnen des Sitzplans auswählen.
  5. Steuerung: viele Sitze auf einmal hinzufügen, Raster‑Snapping umschalten (empfohlen: EIN).
  6. Ein Info‑Panel fasst Statistiken abhängig von Lernenden und Algorithmus zusammen.

• Lernenden‑Ansicht

  1. Links: Liste aller Lernenden mit Wünschen/Ablehnungen und Zählern (gewünscht von, abgelehnt von, Differenz = Wünsche − Ablehnungen). Klick zum Bearbeiten. Der rote Papierkorb löscht. Ein „*“ markiert Namen, die noch nicht als eigener Eintrag existieren.
  2. Rechts: Formular zum Anlegen/Bearbeiten. WICHTIG: Jeden Wunsch/Ablehnung mit ENTER bestätigen und Namen exakt (inkl. Groß-/Kleinschreibung) schreiben, damit Verknüpfungen entstehen.
  3. Lernendenliste als JSON exportieren/importieren, z. B. um nach einem Reload weiterzuarbeiten.

Datenschutz

• Keine Server‑Datenbank. Alles liegt nur in der aktuellen Browsersitzung.
• Beim Neuladen/Schließen des Tabs gehen Daten verloren, sofern nicht exportiert.
• Exportieren Sie die Lernendenliste, bevor Sie die Seite verlassen, wenn Sie später weitermachen möchten.

Import/Export‑Formate

• Lernende (Beispiel):

{
  "Alice": {
    "wishes": ["Bob"],
    "rejects": ["Eve"]
  },
  "Bob": {
    "wishes": ["Alice"],
    "rejects": []
  }
}

• Tischanordnung (Beispiel):

{
  "seats": [
    { "id": 1, "x": 0, "y": 0 },
    { "id": 2, "x": 120, "y": 0 },
    { "id": 3, "x": 0, "y": 120 }
  ]
}

Vordefinierte Anordnungen können aus dem Menü geladen und nach Bedarf angepasst werden.

Tipps für gute Ergebnisse

• Raster‑Snapping eingeschaltet lassen, damit „Nachbarschaften“ korrekt erkannt werden.
• Erst Tische anordnen, dann alle Lernenden anlegen, dann Algorithmus ausführen und anschließend per Drag & Drop feinjustieren.
• Einheitliche, korrekt geschriebene Namen verwenden, damit Wünsche/Ablehnungen verknüpft werden.