{
    "model": {
        "rank": 9782,
        "code": "thing-q629206",
        "model_id": "vr.tr.computer-language",
        "name": "computer language",
        "purpose": "Let an agent explain computer languages as a category, classify their kinds, relay how they are defined and standardised, and distinguish computer languages from natural languages and from programming languages specifically.",
        "family": "Thing Registry",
        "category": "Information and virtual systems",
        "status": "research-draft",
        "kind": "thing",
        "plane": "INF",
        "domain": "INF.MED",
        "industry": "",
        "version": "",
        "url": "/models/thing/q629206/",
        "tier": 2,
        "score": 46,
        "payload": {
            "layer": "wikidata",
            "aliases": [
                "Structure of Management Information",
                "Gherkin (BDD language)",
                "style sheet language",
                "data description language",
                "specification language",
                "general-purpose language",
                "modeling language",
                "machine language",
                "database language",
                "off-side rule language",
                "Daplex",
                "language complexity",
                "domain-specific language",
                "O-code",
                "transformation language",
                "query language",
                "spacecraft command language",
                "user interface style sheet language",
                "Managed Object Format",
                "model transformation language",
                "data modeling language",
                "ontology language",
                "D",
                "embedded domain-specific language",
                "external domain-specific language",
                "template language",
                "Jaql",
                "Language Integrated Query",
                "Graph Query Language",
                "information retrieval query language",
                "data query language",
                "LINQ to Entities"
            ],
            "aliasCount": 32,
            "merged": 32,
            "knownIn": 46,
            "facets": null,
            "markers": [],
            "lexicalClass": "",
            "senseRank": null,
            "alsoRegisteredAs": "vr.tr.computer-language",
            "source": {
                "dataset": "wikidata",
                "item": "Q629206",
                "url": "https://www.wikidata.org/wiki/Q629206",
                "license": "CC0 1.0"
            }
        },
        "research": {
            "vercy": "1.0-draft",
            "publication": {
                "status": "research-draft",
                "adjudicationStatus": "unreviewed",
                "publishableCanonical": false,
                "generatedAt": "2026-09-13T01:44:01Z",
                "providers": [
                    "Claude"
                ],
                "breadth": "written by Claude from model knowledge without web access - no source was read, every claim is a lead to verify",
                "pass": 2,
                "wave": 3,
                "engine": "claude"
            },
            "metaModel": {
                "id": "THING-Q629206",
                "registryId": "vr.tr.computer-language",
                "name": "computer language",
                "version": "0.2.0-wave.3",
                "entryKind": "thing",
                "family": "Thing Registry",
                "domain": [
                    "INF.MED"
                ],
                "status": "research-draft"
            },
            "canonicalUrl": "https://ver.cy/models/thing/q629206/",
            "model": {
                "registry_id": "vr.tr.computer-language",
                "name": "computer language",
                "purpose": "Let an agent explain computer languages as a category, classify their kinds, relay how they are defined and standardised, and distinguish computer languages from natural languages and from programming languages specifically.",
                "definition": "A formal language designed for communication with or between computers, encompassing programming languages, markup and style sheet languages, data description and query languages, specification languages, configuration and modelling languages, and domain-specific languages such as Gherkin for behaviour-driven development and the Structure of Management Information for network management; computer languages are defined by syntax and semantics, implemented by compilers and interpreters, and classified as general-purpose or domain-specific.",
                "what_it_is_for": "Communicating instructions and data with computers.",
                "affordances": [
                    "explain the category and kinds",
                    "relay definition and standardisation",
                    "describe classification",
                    "distinguish from natural and programming languages"
                ],
                "distinguishing_features": [
                    "Formal syntax and semantics",
                    "Machine processing",
                    "General-purpose or domain-specific",
                    "Standards and implementations"
                ],
                "appearance": "Not a visible object; text in defined syntax.",
                "visual_identification": [
                    "Formal language for computers",
                    "Programming, markup, style sheet, data, query, specification and domain-specific languages",
                    "Natural languages are human; programming languages are one kind of computer language"
                ],
                "physical_properties": [
                    {
                        "quantity": "programming languages documented",
                        "typical_range": "thousands",
                        "unit": "count",
                        "note": "historical catalogues"
                    }
                ],
                "families_and_kinds": [
                    "programming languages",
                    "markup languages such as HTML and XML",
                    "style sheet languages such as CSS",
                    "data description and query languages such as SQL and JSON Schema",
                    "specification and modelling languages",
                    "configuration and build languages",
                    "domain-specific languages such as Gherkin and SMI"
                ],
                "related_models": [
                    {
                        "relation": "is a kind of",
                        "target": "formal language",
                        "why": "in registry terms"
                    },
                    {
                        "relation": "is a kind of",
                        "target": "intellectual work",
                        "why": "in registry terms"
                    },
                    {
                        "relation": "includes",
                        "target": "programming language",
                        "why": "as a major kind"
                    },
                    {
                        "relation": "is contrasted with",
                        "target": "natural language",
                        "why": "used by humans"
                    }
                ],
                "identifiers": [
                    {
                        "scheme": "ISO/IEC 2382",
                        "value_or_pattern": "vocabulary",
                        "note": "information technology"
                    }
                ],
                "standards_and_regulation": [
                    "ISO, ECMA, W3C and IETF language standards",
                    "Open source licences for implementations",
                    "No regulation of languages as such"
                ],
                "failure_modes_and_hazards": [
                    "Blurred category boundaries",
                    "Confusing language with implementation",
                    "Obsolescence"
                ],
                "in_scope": [],
                "out_of_scope": [],
                "characteristics": []
            },
            "sources": [],
            "structure": {
                "bundles": [
                    {
                        "id": "understand",
                        "name": "Understand",
                        "description": "What a computer language is.",
                        "rationale": "Definition.",
                        "layers": [
                            {
                                "id": "definition",
                                "name": "Definition",
                                "description": "Definition and kinds.",
                                "findings": [
                                    {
                                        "id": "definition-finding",
                                        "name": "Definition",
                                        "description": "Definition.",
                                        "questions": [
                                            {
                                                "text": "What is a computer language, and what kinds exist beyond programming languages?",
                                                "kind": "definition"
                                            },
                                            {
                                                "text": "Is the question about computer languages in general or a specific kind or language?",
                                                "kind": "boundary"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "classification",
                                "name": "Classification",
                                "description": "Classification.",
                                "findings": [
                                    {
                                        "id": "classification-finding",
                                        "name": "Classification",
                                        "description": "Classification.",
                                        "questions": [
                                            {
                                                "text": "How are languages classified as general-purpose or domain-specific, and by paradigm and purpose?",
                                                "kind": "definition"
                                            },
                                            {
                                                "text": "Which entry fits the specific language?",
                                                "kind": "action"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "define",
                        "name": "Define",
                        "description": "Definition and implementation.",
                        "rationale": "Practice.",
                        "layers": [
                            {
                                "id": "syntax",
                                "name": "Syntax",
                                "description": "Syntax and semantics.",
                                "findings": [
                                    {
                                        "id": "syntax-finding",
                                        "name": "Syntax",
                                        "description": "Syntax.",
                                        "questions": [
                                            {
                                                "text": "How are computer languages defined by grammars and semantics?",
                                                "kind": "provenance"
                                            },
                                            {
                                                "text": "Which references are standard?",
                                                "kind": "provenance"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "implementation",
                                "name": "Implementation",
                                "description": "Compilers and interpreters.",
                                "findings": [
                                    {
                                        "id": "implementation-finding",
                                        "name": "Implementation",
                                        "description": "Implementation.",
                                        "questions": [
                                            {
                                                "text": "How are languages implemented and standardised?",
                                                "kind": "provenance"
                                            },
                                            {
                                                "text": "Which entry fits compiler?",
                                                "kind": "action"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "kinds",
                        "name": "Kinds",
                        "description": "Specific kinds.",
                        "rationale": "Context.",
                        "layers": [
                            {
                                "id": "markup",
                                "name": "Markup",
                                "description": "Markup, style and data languages.",
                                "findings": [
                                    {
                                        "id": "markup-finding",
                                        "name": "Markup",
                                        "description": "Markup.",
                                        "questions": [
                                            {
                                                "text": "What are markup, style sheet, data description and query languages, with examples?",
                                                "kind": "provenance"
                                            },
                                            {
                                                "text": "Which entry fits the specific kind?",
                                                "kind": "action"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "dsl",
                                "name": "DSL",
                                "description": "Domain-specific and specification languages.",
                                "findings": [
                                    {
                                        "id": "dsl-finding",
                                        "name": "DSL",
                                        "description": "DSL.",
                                        "questions": [
                                            {
                                                "text": "What are domain-specific and specification languages such as Gherkin and SMI, and when are they used?",
                                                "kind": "provenance"
                                            },
                                            {
                                                "text": "Which sources are cited?",
                                                "kind": "provenance"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "context",
                        "name": "Context",
                        "description": "History and theory.",
                        "rationale": "Context.",
                        "layers": [
                            {
                                "id": "history",
                                "name": "History",
                                "description": "History.",
                                "findings": [
                                    {
                                        "id": "history-finding",
                                        "name": "History",
                                        "description": "History.",
                                        "questions": [
                                            {
                                                "text": "How did computer languages develop from machine code to modern languages?",
                                                "kind": "provenance"
                                            },
                                            {
                                                "text": "Which entry fits the history of programming languages?",
                                                "kind": "action"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "theory",
                                "name": "Theory",
                                "description": "Formal language theory.",
                                "findings": [
                                    {
                                        "id": "theory-finding",
                                        "name": "Theory",
                                        "description": "Theory.",
                                        "questions": [
                                            {
                                                "text": "How does formal language theory underpin computer languages?",
                                                "kind": "provenance"
                                            },
                                            {
                                                "text": "Which entry fits formal language?",
                                                "kind": "action"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    }
                ]
            },
            "openQuestions": [
                "Should programming language be the primary linked entry?",
                "How should standards bodies be linked?",
                "The registry entry has merged aliases naming specific languages and kinds; should they be split off?"
            ],
            "statistics": {
                "bundles": 4,
                "layers": 8,
                "findings": 8,
                "questions": 16
            }
        },
        "draft": {
            "generator": "vr.draft.v3",
            "status": "draft-generated",
            "researched": false,
            "archetype": "language",
            "method": "Written from the archetype playbook - what this kind of thing needs beyond identity and provenance - and from the structure that recurred across 6,333 models already researched by two engines. Applied to this entry by rule. No source was read for this thing and no claim here is researched. This entry carries no facets of its own, so they were inferred from its domain - a guess about a whole domain applied to one thing.",
            "facetsInferred": true,
            "nextPass": "A researcher replaces this draft with a sourced specification. Treat every sentence below as a proposal to argue with.",
            "purpose": "Give an agent a durable, checkable way to recognise a computer language, record what state it is in, and decide what may be done with it.",
            "whatItIs": "Let an agent explain computer languages as a category, classify their kinds, relay how they are defined and standardised, and distinguish computer languages from natural languages and from programming languages specifically.",
            "characteristics": {
                "substance": "information",
                "origin": "conceptual",
                "agency": "inert"
            },
            "whatYouCanDoWithIt": [
                "read and interpreted",
                "observed and measured"
            ],
            "distinguishingFeatures": [
                "Names folded into this entry, which a task may need to split apart again: Structure of Management Information, Gherkin (BDD language), style sheet language, data description language, specification language, general-purpose language, modeling language, machine language, database language, off-side rule language, Daplex, language complexity.",
                "32 finer distinctions are held as aliases rather than separate entries, because telling them apart needs a task that asks for it.",
                "Described in 46 Wikipedia languages, which is a measure of how widely the thing is known, not of how important it is."
            ],
            "openQuestionsForResearch": [
                "Which of the bundles below does a real task actually need, and which are ceremony?",
                "What does this thing have that the facets do not capture at all?",
                "Which neighbouring kind is most often confused with a computer language, and on what evidence are they told apart?"
            ],
            "whatItIsMadeOf": "content that has to be carried by something else",
            "physicalCharacter": [
                "Does nothing on its own; everything it does, something else did to it.",
                "These come from the domain this entry sits in rather than from the entry itself, so treat them as a first guess about the whole domain applied to one thing."
            ],
            "whatCanBeDoneWithIt": [
                "read it and act on what it says",
                "observe it, measure it, record its state"
            ],
            "howItIsRecognised": [
                "Recognised from text or speech by script, vocabulary and grammar - and script is the weakest of the three, since several languages share one."
            ],
            "relatedModels": [
                {
                    "relation": "covers",
                    "note": "Finer kinds folded into this entry because telling them apart needs a task that asks for it. Each is a model waiting to be split out when one does.",
                    "targets": [
                        "Structure of Management Information",
                        "Gherkin (BDD language)",
                        "style sheet language",
                        "data description language",
                        "specification language",
                        "general-purpose language",
                        "modeling language",
                        "machine language",
                        "database language",
                        "off-side rule language",
                        "Daplex",
                        "language complexity"
                    ]
                }
            ],
            "standing": "Described in 46 Wikipedia languages, which measures how widely it is written about rather than how important or how common it is. 32 finer distinctions are held inside this entry as names rather than as separate models.",
            "structure": {
                "bundles": [
                    {
                        "id": "identity-and-classification",
                        "name": "Identity, naming and classification",
                        "description": "How an agent tells one computer language from another, and a computer language from things that resemble it.",
                        "rationale": "Recognition comes before every other claim. Without stable identity nothing else in the model can be trusted to be about the same thing twice.",
                        "layers": [
                            {
                                "id": "naming-and-identifiers",
                                "name": "Names and identifiers",
                                "description": "The names this thing goes by and the identifiers that survive translation and time.",
                                "findings": [
                                    {
                                        "id": "preferred-name-and-aliases",
                                        "name": "Preferred name, aliases and local names",
                                        "description": "Which name to use, which names mean the same thing, and which merely sound similar.",
                                        "questions": [
                                            {
                                                "id": "preferred-name-and-aliases-q01",
                                                "text": "What identifies and describes the name of a computer language, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "preferred-name-and-aliases-q02",
                                                "text": "Who or what asserted this about the name of a computer language, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "preferred-name-and-aliases-q03",
                                                "text": "What may an agent decide or do once the name of a computer language is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    },
                                    {
                                        "id": "stable-identifiers",
                                        "name": "Stable identifiers and external keys",
                                        "description": "Identifiers that keep pointing at this kind of thing across systems and languages.",
                                        "questions": [
                                            {
                                                "id": "stable-identifiers-q01",
                                                "text": "What identifies and describes an identifier for a computer language, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "stable-identifiers-q02",
                                                "text": "Who or what asserted this about an identifier for a computer language, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "stable-identifiers-q03",
                                                "text": "What may an agent decide or do once an identifier for a computer language is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "classification-and-granularity",
                                "name": "Classification and granularity",
                                "description": "Where a computer language sits among kinds, and how finely a task needs to cut it.",
                                "findings": [
                                    {
                                        "id": "kind-and-parents",
                                        "name": "Kind, parents and neighbouring kinds",
                                        "description": "The classes this thing belongs to and the ones it is next to.",
                                        "questions": [
                                            {
                                                "id": "kind-and-parents-q01",
                                                "text": "What identifies and describes the kind of a computer language, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "kind-and-parents-q02",
                                                "text": "Who or what asserted this about the kind of a computer language, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "kind-and-parents-q03",
                                                "text": "What may an agent decide or do once the kind of a computer language is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    },
                                    {
                                        "id": "distinguishing-features",
                                        "name": "Distinguishing features",
                                        "description": "What separates a computer language from the things most often confused with it.",
                                        "questions": [
                                            {
                                                "id": "distinguishing-features-q01",
                                                "text": "What identifies and describes what distinguishes a computer language, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "distinguishing-features-q02",
                                                "text": "Who or what asserted this about what distinguishes a computer language, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "distinguishing-features-q03",
                                                "text": "What may an agent decide or do once what distinguishes a computer language is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "state-and-lifecycle",
                        "name": "State and lifecycle",
                        "description": "The states a computer language passes through and the events that move it between them.",
                        "rationale": "Most decisions about a thing depend on what state it is in now, which is a claim with a time on it, not a property.",
                        "layers": [
                            {
                                "id": "lifecycle-stages",
                                "name": "Lifecycle stages",
                                "description": "From coming into existence to ceasing to be one of these.",
                                "findings": [
                                    {
                                        "id": "stages-and-transitions",
                                        "name": "Stages and transitions",
                                        "description": "The stages worth naming and what moves a computer language between them.",
                                        "questions": [
                                            {
                                                "id": "stages-and-transitions-q01",
                                                "text": "What identifies and describes the lifecycle of a computer language, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "stages-and-transitions-q02",
                                                "text": "Who or what asserted this about the lifecycle of a computer language, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "stages-and-transitions-q03",
                                                "text": "What may an agent decide or do once the lifecycle of a computer language is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "observations-and-status",
                                "name": "Observations and current status",
                                "description": "What is observed about a computer language, how often and by whom.",
                                "findings": [
                                    {
                                        "id": "observation-record",
                                        "name": "Observation record",
                                        "description": "How an observation of a computer language is recorded so that it can be superseded rather than overwritten.",
                                        "questions": [
                                            {
                                                "id": "observation-record-q01",
                                                "text": "What identifies and describes an observation of a computer language, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "observation-record-q02",
                                                "text": "Who or what asserted this about an observation of a computer language, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "observation-record-q03",
                                                "text": "What may an agent decide or do once an observation of a computer language is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "content-and-access",
                        "name": "Content, encoding and access",
                        "description": "What a computer language says, how it is encoded and who may read it.",
                        "rationale": "An informational thing carries content that can be copied, versioned and withheld, none of which its physical carrier explains.",
                        "layers": [
                            {
                                "id": "content-and-encoding",
                                "name": "Content and encoding",
                                "description": "The content itself, its format and its language.",
                                "findings": [
                                    {
                                        "id": "content-and-format",
                                        "name": "Content, format and language",
                                        "description": "What a computer language contains and in what form it is held.",
                                        "questions": [
                                            {
                                                "id": "content-and-format-q01",
                                                "text": "What identifies and describes the content of a computer language, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "content-and-format-q02",
                                                "text": "Who or what asserted this about the content of a computer language, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "content-and-format-q03",
                                                "text": "What may an agent decide or do once the content of a computer language is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "access-and-rights",
                                "name": "Access, rights and retention",
                                "description": "Who may read, copy or change it, and for how long it is kept.",
                                "findings": [
                                    {
                                        "id": "access-rules",
                                        "name": "Access rules and retention",
                                        "description": "The permissions attached to a computer language and the period it survives.",
                                        "questions": [
                                            {
                                                "id": "access-rules-q01",
                                                "text": "What identifies and describes access to a computer language, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "access-rules-q02",
                                                "text": "Who or what asserted this about access to a computer language, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "access-rules-q03",
                                                "text": "What may an agent decide or do once access to a computer language is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "speakers-and-standing",
                        "name": "Speakers, communities and standing",
                        "description": "Who speaks computer language, how many, and what status it holds where they live.",
                        "rationale": "Speaker numbers move, and legal standing changes without the language changing. Both are claims with a date and a source, never properties.",
                        "layers": [
                            {
                                "id": "speaker-populations",
                                "name": "Speaker populations",
                                "description": "Counts by kind of speaker, each with the year and the method behind it.",
                                "findings": [
                                    {
                                        "id": "population-estimates",
                                        "name": "Population estimates and their basis",
                                        "description": "First-language and second-language counts, who produced them and how.",
                                        "questions": [
                                            {
                                                "id": "population-estimates-q01",
                                                "text": "How many first-language and second-language speakers of computer language are claimed, for which year, and by whom?",
                                                "kind": "measurement"
                                            },
                                            {
                                                "id": "population-estimates-q02",
                                                "text": "What method produced that estimate - census, survey, projection - and what does it systematically miss?",
                                                "kind": "provenance"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "official-standing",
                                "name": "Official standing and policy",
                                "description": "Where computer language is official, taught, or barred, and under which instrument.",
                                "findings": [
                                    {
                                        "id": "legal-status",
                                        "name": "Legal status by jurisdiction",
                                        "description": "The status held in each place, with the law or treaty that grants it.",
                                        "questions": [
                                            {
                                                "id": "legal-status-q01",
                                                "text": "In which jurisdictions does computer language hold official, regional or minority status, and under what instrument?",
                                                "kind": "definition"
                                            },
                                            {
                                                "id": "legal-status-q02",
                                                "text": "What follows practically from that status - schooling, courts, signage - and what does not?",
                                                "kind": "action"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "varieties-and-writing",
                        "name": "Varieties, registers and writing",
                        "description": "The forms computer language takes, and the scripts and spellings used to write it.",
                        "rationale": "A language is not its script and a standard is not the whole language. A model that conflates them cannot say which variety a text is in.",
                        "layers": [
                            {
                                "id": "varieties-and-continuum",
                                "name": "Varieties and the continuum",
                                "description": "Dialects, standards and the cuts drawn through a continuum that has none of its own.",
                                "findings": [
                                    {
                                        "id": "variety-inventory",
                                        "name": "Varieties and who separated them",
                                        "description": "Named varieties, their relation to the standard, and the authority behind each split.",
                                        "questions": [
                                            {
                                                "id": "variety-inventory-q01",
                                                "text": "Which varieties of computer language are distinguished in practice, and who drew each boundary?",
                                                "kind": "boundary"
                                            },
                                            {
                                                "id": "variety-inventory-q02",
                                                "text": "Which neighbouring lect is treated as the same language by one authority and a different one by another?",
                                                "kind": "boundary"
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "script-and-orthography",
                                "name": "Script and orthography",
                                "description": "Writing systems in use, competing spellings, and reform history.",
                                "findings": [
                                    {
                                        "id": "writing-systems",
                                        "name": "Writing systems and orthographies",
                                        "description": "Scripts computer language is written in and which spelling convention applies where.",
                                        "questions": [
                                            {
                                                "id": "writing-systems-q01",
                                                "text": "Which scripts and orthographies are in use for computer language, and where does each apply?",
                                                "kind": "definition"
                                            },
                                            {
                                                "id": "writing-systems-q02",
                                                "text": "What identifies the orthography of a given text, and what should an agent do when it cannot tell?",
                                                "kind": "action"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "codes-and-alignment",
                        "name": "Codes and external alignment",
                        "description": "The identifiers that name computer language across systems.",
                        "rationale": "Language codes are how every other system will refer to this, and they disagree with each other in known ways.",
                        "layers": [
                            {
                                "id": "identifier-schemes",
                                "name": "Identifier schemes",
                                "description": "ISO 639 parts, Glottolog, and the granularity each assumes.",
                                "findings": [
                                    {
                                        "id": "codes-and-granularity",
                                        "name": "Codes and the granularity they encode",
                                        "description": "Which code refers to this language and which refers to a group containing it.",
                                        "questions": [
                                            {
                                                "id": "codes-and-granularity-q01",
                                                "text": "Which ISO 639-1, 639-2 and 639-3 codes apply to computer language, and do they refer to the same extent?",
                                                "kind": "definition"
                                            },
                                            {
                                                "id": "codes-and-granularity-q02",
                                                "text": "Where do the schemes disagree about whether this is one language or several?",
                                                "kind": "boundary"
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    },
                    {
                        "id": "provenance-and-evidence",
                        "name": "Provenance, evidence and time",
                        "description": "Where every claim about a computer language came from and when it held.",
                        "rationale": "A claim without a source and a time cannot be superseded, only overwritten, and an agent that overwrites loses the ability to explain itself.",
                        "layers": [
                            {
                                "id": "source-and-authority",
                                "name": "Source and authority",
                                "description": "Who said it, on what evidence, and how strongly.",
                                "findings": [
                                    {
                                        "id": "claim-provenance",
                                        "name": "Claim provenance and confidence",
                                        "description": "The authority behind each claim about a computer language and how confident it is.",
                                        "questions": [
                                            {
                                                "id": "claim-provenance-q01",
                                                "text": "What identifies and describes a claim about a computer language, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "claim-provenance-q02",
                                                "text": "Who or what asserted this about a claim about a computer language, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "claim-provenance-q03",
                                                "text": "What may an agent decide or do once a claim about a computer language is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            },
                            {
                                "id": "time-and-versions",
                                "name": "Time, versions and supersession",
                                "description": "When a claim was true, when it was learnt, and what replaced it.",
                                "findings": [
                                    {
                                        "id": "validity-and-supersession",
                                        "name": "Validity period and supersession",
                                        "description": "How an old claim about a computer language is retired without being erased.",
                                        "questions": [
                                            {
                                                "id": "validity-and-supersession-q01",
                                                "text": "What identifies and describes the validity of a claim about a computer language, and in what units or vocabulary?",
                                                "kind": "definition",
                                                "answer_data": [
                                                    "identifiers",
                                                    "types and classes",
                                                    "values with units",
                                                    "explicit unknowns"
                                                ]
                                            },
                                            {
                                                "id": "validity-and-supersession-q02",
                                                "text": "Who or what asserted this about the validity of a claim about a computer language, by which method, and when was it true?",
                                                "kind": "provenance",
                                                "answer_data": [
                                                    "authority",
                                                    "method",
                                                    "evidence",
                                                    "event time",
                                                    "knowledge time"
                                                ]
                                            },
                                            {
                                                "id": "validity-and-supersession-q03",
                                                "text": "What may an agent decide or do once the validity of a claim about a computer language is known, and what must it refuse?",
                                                "kind": "action",
                                                "answer_data": [
                                                    "permitted actions",
                                                    "preconditions",
                                                    "refusals",
                                                    "escalation"
                                                ]
                                            }
                                        ]
                                    }
                                ]
                            }
                        ]
                    }
                ]
            },
            "statistics": {
                "bundles": 7,
                "layers": 13,
                "findings": 15,
                "questions": 40
            }
        }
    }
}