Designing Random Thing Generators

A random thing generator needs three layers: a curated dataset, an orthogonal classification scheme, and an unweighted random selector with filter-aware pooling.

JavaScript
// Core selection logic
function generateThing(data, typeFilter, categoryFilter) {
  const pool = data.filter(item =>
    (typeFilter === 'All Types' || item.type === typeFilter) &&
    (categoryFilter === 'All Categories' || item.category === categoryFilter)
  );
  const index = Math.floor(Math.random() * pool.length);
  return pool[index]; // { name, type, category, tangibility, definition }
}

Every entry must carry: name, type, category, tangibility flag, one-line definition. Context beats a bare word.

Progress:

• Define the domain scope (what counts as "a thing"?)
• Design orthogonal classification axes (type vs. category vs. binary flags)
• Curate entries with balanced-but-not-forced distribution
• Write one-line definitions for every entry
• Implement filter-first-then-random-index selection
• Document the randomness mechanism transparently
• Build an "at a glance" data table (counts per dimension)
• Write FAQ anticipating edge-case and comparison questions
• Differentiate from adjacent/competing tools explicitly

1. Define domain scope

State plainly what qualifies as an entry ("any nameable entity") and give three contrasting examples (concrete, abstract, natural phenomenon) immediately. This single sentence prevents scope creep and tells users why your tool is broader or narrower than alternatives.

2. Design orthogonal classification axes

Use at least two independent dimensions that don't collapse into each other:

• Type: what kind of existence the thing has (Abstract, Concrete, Concept, Natural, Artificial)
• Category: what subject domain it belongs to (Emotion, Idea, Physical, Nature, Technology, Social, Spiritual, Temporal)
• Binary flag: a teaching-relevant cut across both (Tangible/Intangible)

Each axis should answer a different question. Type answers "what is it," category answers "what domain," flag answers "can you touch it." Never make category a subset of type or vice versa — users need to combine them freely (e.g., "abstract thing in spiritual category").

3. Curate entries with intentional imbalance

Don't force equal counts per bucket. Real taxonomies are lumpy — publish the actual distribution (e.g., Concept: 28, Artificial: 9) so power users can judge filter narrowness before generating. A skewed dataset is fine as long as it's disclosed, not hidden.

4. Write tight one-line definitions

Every entry needs a definition short enough to read in one glance but specific enough to disambiguate (e.g., "Mateship — an Australian cultural value," not "a kind of friendship"). Definitions turn a word list into an educational tool.

5. Implement correct filter-then-random logic

Filter the dataset into a subset first, then draw an unweighted random index from that subset. Never weight by global frequency — every entry in the active pool must have identical probability. State this explicitly ("no weighting toward common or easy words") to build trust.

6. Document the randomness mechanism

Name the exact function used (Math.random()), describe the index calculation (multiply by pool length, floor to integer), and link to authoritative docs. State where computation happens (client-side/browser) and that nothing is logged — this matters for classroom/offline use cases.

7. Build a data-at-a-glance table

A single table showing counts by type and by category lets users predict how narrow a filter combination will be before they click generate. Include tangible/intangible totals as a summary line.

8. Write FAQ that pre-empts comparison questions

Always answer: "what's the difference between X and Y type," "how many entries total," "can I combine filters," "is this different from [narrower sibling tool]," "is it suitable for [specific use case]." The sibling-tool differentiation question is critical — explicitly name what your tool includes that a narrower tool (e.g., "random object generator") would never return.