{ "model": { "rank": 3382, "code": "thing-q165436", "model_id": "vr.tr.assembly-language", "name": "assembly language", "purpose": "Enable an agent to identify an assembly-language dialect, assess whether its source can be interpreted and translated for a specified target, and determine which modifications or uses are justified.", "family": "Thing Registry", "category": "Information and virtual systems", "status": "research-draft", "kind": "thing", "plane": "INF", "domain": "INF.MED", "industry": "", "version": "", "url": "/models/thing/q165436/", "tier": 2, "score": 86, "payload": { "layer": "wikidata", "aliases": [ "ASSIRIS", "inline assembler", "Graphics Programming Language" ], "aliasCount": 3, "merged": 3, "knownIn": 86, "facets": null, "markers": [], "lexicalClass": "", "senseRank": null, "alsoRegisteredAs": "vr.tr.assembly-language", "source": { "dataset": "wikidata", "item": "Q165436", "url": "https://www.wikidata.org/wiki/Q165436", "license": "CC0 1.0" } }, "research": { "vercy": "1.0-draft", "publication": { "status": "research-draft", "adjudicationStatus": "unreviewed", "publishableCanonical": false, "generatedAt": "2026-09-07T14:36:40Z", "providers": [ "Codex" ], "breadth": "recalled by Codex without web access - no source was read", "missingProviders": [], "pass": 2, "cost": { "grok": { "seconds": 26.4, "error": "Reading additional input from stdin...\nOpenAI Codex v0.153.3\n--------\nworkdir: R:\\02_PROJECTS\\02_Meta_Models_Platforms\\Ver.cy\\current\\thing-registry-backlog\nmodel: gpt-6-astra\nprovider: openai\napproval: never\nsandbox: read-only\nreasoning effort: none\nreasoning summaries: none\nsession id: 01a07c4b-b1b5-7882-90b2-316c4326a291\n--------\nuser\nDescribe what is already known about one registered thing. Answer as JSON only, no prose around it.\n\nThing: assembly language\nSense to describe: (none recorded)\nDomain code: INF.MED\nAlso known as: (none)\n\n\nContext for this batch of 546 things:\n# Batch 003: 100", "usd": 0, "recall": true }, "codex": { "seconds": 70.3, "error": "Reading additional input from stdin...\nOpenAI Codex v0.153.3\n--------\nworkdir: R:\\02_PROJECTS\\02_Meta_Models_Platforms\\Ver.cy\\current\\thing-registry-backlog\nmodel: gpt-6-astra\nprovider: openai\napproval: never\nsandbox: read-only\nreasoning effort: none\nreasoning summaries: none\nsession id: 01a07c4b-b1bb-77c0-978d-425640229944\n--------\nuser\nYou are drafting a Vercy meta-model for one registered thing. Answer as JSON only, no prose around it.\n\nThing: assembly language\nRegistry id: vr.tr.assembly-language\nPlane / domain: INF / INF.MED\nRegistry definition: (none recorded)\nNames folded into this entr" } } }, "metaModel": { "id": "THING-Q165436", "registryId": "vr.tr.assembly-language", "name": "assembly language", "version": "0.1.0-research.1", "entryKind": "thing", "family": "Thing Registry", "domain": [ "INF.MED" ], "status": "research-draft" }, "canonicalUrl": "https://ver.cy/models/thing/q165436/", "model": { "registry_id": "vr.tr.assembly-language", "name": "assembly language", "purpose": "Enable an agent to identify an assembly-language dialect, assess whether its source can be interpreted and translated for a specified target, and determine which modifications or uses are justified.", "definition": "Assembly language is an architecture-specific programming language that represents machine instructions and operands symbolically, usually alongside labels and assembler directives, for translation into machine code by an assembler.", "scope_statement": "This model owns assembly language as a family of symbolic programming languages tied to machine instruction sets, including dialect-specific notation, assembly semantics and target constraints; individual dialects must be identified explicitly.", "in_scope": [ "Relationships among an assembly-language dialect, instruction-set architecture, architecture revision and execution mode", "Mnemonic, operand, register, literal, label and expression notation", "Assembler directives, macros, conditional assembly and pseudo-instructions", "Rules for resolving symbols, selecting encodings and emitting sections or relocation records", "Requirements for interpreting, translating and modifying assembly source under an identified toolchain" ], "out_of_scope": [ "Processor hardware design and microarchitecture except where they constrain source interpretation", "Machine-code formats and instruction-set specifications as independently maintained things", "Assembler, linker and debugger implementations as software products", "Application-specific algorithms and program behavior beyond their expression in assembly", "Natural-language speaker populations, orthographies and official-language status", "Compiler intermediate representations and higher-level programming languages" ], "distinguishing_features": [ "Ordinary executable statements name target instructions and operands, although macros and pseudo-instructions can prevent a one-statement-to-one-instruction correspondence.", "Source interpretation depends on an identified instruction set and dialect; a mnemonic alone does not establish a compatible language.", "The source contains symbolic names and assembly-time constructs, distinguishing it from encoded machine instructions.", "Register and addressing notation expose target-specific execution resources more directly than typical higher-level languages.", "Disassembler output qualifies as reusable source only when its syntax and retained information satisfy a particular assembler." ], "characteristics": [ { "name": "Target instruction-set binding", "kind": "relation", "unit_or_values": "Architecture, revision, execution mode and enabled extensions", "why_it_matters": "Determines which instructions, registers and operand forms can be interpreted." }, { "name": "Dialect and syntax profile", "kind": "category", "unit_or_values": "Named dialect plus operand order, register notation, literal syntax and case rules", "why_it_matters": "Superficially similar statements can be parsed differently across dialects." }, { "name": "Assembler compatibility", "kind": "relation", "unit_or_values": "Assembler implementation, version, options and documented support", "why_it_matters": "Makes claims about accepted syntax and emitted output reproducible." }, { "name": "Assembly-time capabilities", "kind": "category", "unit_or_values": "Supported directives, expressions, macros, conditional assembly and pseudo-instructions", "why_it_matters": "Identifies transformations that occur before executable instructions exist." }, { "name": "Emission context", "kind": "relation", "unit_or_values": "Object format or raw-image format, section conventions and relocation model", "why_it_matters": "Determines how symbolic source becomes an artifact that can be linked or loaded." }, { "name": "Address and operand widths", "kind": "measurement", "unit_or_values": "Bits, qualified by target mode and instruction form", "why_it_matters": "Constrains operand interpretation, addressing and representable values." }, { "name": "Execution prerequisites", "kind": "relation", "unit_or_values": "Required privilege level, processor features, runtime environment and interface conventions", "why_it_matters": "Separates successful assembly from eligibility to execute in a particular environment." }, { "name": "Compatibility evidence state", "kind": "state", "unit_or_values": "Unassessed, documented, assembly-tested, execution-tested or contradicted, with explicit scope", "why_it_matters": "Prevents a successful test for one configuration from becoming an unsupported general compatibility claim." } ], "affordances": [ "Identify a source dialect and enumerate the target assumptions needed to interpret it.", "Check mnemonic, operand and directive usage against a specified dialect and target profile.", "Expand assembly-time constructs and inspect how statements map to emitted instructions and data.", "Assemble source in a controlled environment and inspect symbols, sections, relocations and diagnostics.", "Translate between dialects while recording semantic differences and unresolved equivalence claims.", "Assess whether a proposed edit preserves instruction behavior, layout constraints and interface obligations." ] }, "sources": [], "structure": { "bundles": [ { "id": "dialect-and-target-identity", "name": "Dialect and target identity", "description": "Establish which assembly language is meant and the machine context that gives its statements meaning.", "rationale": "Assembly language is a family designation; reliable interpretation requires a dialect and target profile.", "layers": [ { "id": "dialect-boundaries", "name": "Dialect boundaries", "description": "Separate family names, syntax variants and implementation-specific language extensions.", "findings": [ { "id": "identify-dialect-authority", "name": "Identify dialect authority", "description": "Record the evidence that defines the dialect and distinguish documented syntax from inferred source recognition.", "questions": [ { "text": "Which dialect, syntax mode and documentation version define the source being modeled?", "kind": "definition", "id": "identify-dialect-authority-q01" }, { "text": "Which language rules come from an architecture specification, and which come from an assembler implementation?", "kind": "provenance", "id": "identify-dialect-authority-q02" } ] } ] }, { "id": "architecture-profile", "name": "Architecture profile", "description": "Capture the instruction-set and execution-mode assumptions required for interpretation.", "findings": [ { "id": "resolve-target-profile", "name": "Resolve target profile", "description": "Bind instruction availability and operand interpretation to a sufficiently precise machine target.", "questions": [ { "text": "Which architecture revision, execution mode and optional instruction-set extensions are assumed?", "kind": "definition", "id": "resolve-target-profile-q01" }, { "text": "Which source constructs become invalid or change meaning when that profile changes?", "kind": "boundary", "id": "resolve-target-profile-q02" } ] } ] } ] }, { "id": "source-notation-and-instruction-meaning", "name": "Source notation and instruction meaning", "description": "Describe how text denotes instructions, operands and symbolic values.", "rationale": "Recognizing mnemonics is insufficient when operand order, widths or addressing notation can alter meaning.", "layers": [ { "id": "statement-and-symbol-syntax", "name": "Statement and symbol syntax", "description": "Identify lexical rules, statement forms and name resolution within source.", "findings": [ { "id": "parse-statements-unambiguously", "name": "Parse statements unambiguously", "description": "Record how instructions, labels, literals, comments and expressions are distinguished.", "questions": [ { "text": "What are the rules for operand order, register prefixes, numeric literals and comments?", "kind": "definition", "id": "parse-statements-unambiguously-q01" }, { "text": "How do case sensitivity, local-label scope and expression precedence affect symbol interpretation?", "kind": "definition", "id": "parse-statements-unambiguously-q02" } ] } ] }, { "id": "operands-and-instruction-effects", "name": "Operands and instruction effects", "description": "Connect parsed instructions to target-defined operand forms and execution effects.", "findings": [ { "id": "resolve-instruction-form", "name": "Resolve instruction form", "description": "Determine the selected instruction form, including implicit operands and width assumptions.", "questions": [ { "text": "How are operand widths, addressing modes and overloaded mnemonic forms resolved?", "kind": "definition", "id": "resolve-instruction-form-q01" }, { "text": "Which explicit and implicit registers, flags, memory locations or control-flow effects must an agent consider before changing this instruction?", "kind": "action", "id": "resolve-instruction-form-q02" } ] } ] } ] }, { "id": "assembly-time-transformation", "name": "Assembly-time transformation", "description": "Capture source processing that produces instructions, data and layout before execution.", "rationale": "Assembly source may generate, suppress or rearrange output through constructs that are not machine instructions.", "layers": [ { "id": "macros-and-pseudo-instructions", "name": "Macros and pseudo-instructions", "description": "Distinguish directly encoded instructions from source constructs expanded by the assembler.", "findings": [ { "id": "trace-source-expansion", "name": "Trace source expansion", "description": "Record expansion rules and configuration-dependent differences in emitted code.", "questions": [ { "text": "Which apparent instructions are aliases, pseudo-instructions or macros, and what determines their expansion?", "kind": "definition", "id": "trace-source-expansion-q01" }, { "text": "Can an expansion introduce temporary-register use, extra instructions or mode-dependent behavior that affects a proposed edit?", "kind": "action", "id": "trace-source-expansion-q02" } ] } ] }, { "id": "directives-and-layout", "name": "Directives and layout", "description": "Model assembly-time control of sections, data, alignment and conditional inclusion.", "findings": [ { "id": "account-for-emitted-layout", "name": "Account for emitted layout", "description": "Identify which constructs emit bytes, reserve space or alter assembly state.", "questions": [ { "text": "Which directives control section selection, alignment, data encoding, includes and conditional assembly?", "kind": "definition", "id": "account-for-emitted-layout-q01" }, { "text": "How many bytes are emitted or reserved by each relevant construct under the selected configuration?", "kind": "measurement", "id": "account-for-emitted-layout-q02" }, { "text": "Which include files, macro definitions and external build values are required to reproduce that layout?", "kind": "provenance", "id": "account-for-emitted-layout-q03" } ] } ] } ] }, { "id": "artifact-and-runtime-contracts", "name": "Artifact and runtime contracts", "description": "Describe the interfaces between assembly source, emitted artifacts and its intended execution environment.", "rationale": "Source can assemble successfully while producing an artifact that cannot link, load or satisfy its calling environment.", "layers": [ { "id": "symbols-relocations-and-output", "name": "Symbols, relocations and output", "description": "Capture the assembly language's expression of linkable names and unresolved addresses.", "findings": [ { "id": "resolve-artifact-obligations", "name": "Resolve artifact obligations", "description": "Record symbol visibility, relocation assumptions and output-format requirements without treating the linker as part of the language.", "questions": [ { "text": "How does the dialect declare exported, imported and local symbols, and which expressions may remain unresolved after assembly?", "kind": "definition", "id": "resolve-artifact-obligations-q01" }, { "text": "Which object format, relocation types or load-address assumptions are required for the intended output?", "kind": "boundary", "id": "resolve-artifact-obligations-q02" } ] } ] }, { "id": "calling-and-execution-environment", "name": "Calling and execution environment", "description": "Record external conventions and prerequisites that constrain usable assembly programs.", "findings": [ { "id": "check-runtime-obligations", "name": "Check runtime obligations", "description": "Distinguish language acceptance from compliance with calling conventions and execution requirements.", "questions": [ { "text": "Which calling convention, register-preservation rules, stack alignment and unwind conventions apply to this use?", "kind": "boundary", "id": "check-runtime-obligations-q01" }, { "text": "What processor-feature, privilege and environment checks are needed before executing the assembled code?", "kind": "action", "id": "check-runtime-obligations-q02" } ] } ] } ] }, { "id": "validation-and-change", "name": "Validation and change", "description": "Define evidence for compatibility, interpretation and preservation of behavior during changes.", "rationale": "Assembly transformations can preserve readable intent while changing encodings, layout or machine-visible effects.", "layers": [ { "id": "reproducible-translation", "name": "Reproducible translation", "description": "Tie acceptance and output claims to documented, repeatable toolchain configurations.", "findings": [ { "id": "establish-translation-evidence", "name": "Establish translation evidence", "description": "Record the conditions and observations supporting a claim that source translates as intended.", "questions": [ { "text": "Which assembler version, options, target settings and input dependencies produced the inspected artifact?", "kind": "provenance", "id": "establish-translation-evidence-q01" }, { "text": "Do emitted instruction bytes, section sizes and relocation records match the stated expectations?", "kind": "measurement", "id": "establish-translation-evidence-q02" } ] } ] }, { "id": "porting-and-semantic-preservation", "name": "Porting and semantic preservation", "description": "Assess dialect conversion and edits against explicit equivalence requirements.", "findings": [ { "id": "bound-transformation-claims", "name": "Bound transformation claims", "description": "Specify what a change must preserve and identify differences that require further evidence.", "questions": [ { "text": "Must the transformation preserve exact bytes, architectural behavior, interface behavior or another explicitly defined property?", "kind": "boundary", "id": "bound-transformation-claims-q01" }, { "text": "Which syntax conversions, instruction substitutions or layout changes require assembly comparison, emulation or execution tests before acceptance?", "kind": "action", "id": "bound-transformation-claims-q02" }, { "text": "Which dependencies on timing, self-modification, hardware state or undocumented behavior remain outside the equivalence evidence?", "kind": "boundary", "id": "bound-transformation-claims-q03" } ] } ] } ] }, { "id": "evidence-and-external-alignment", "name": "Evidence and external alignment", "description": "What the world already says about this thing, gathered so the model can be checked against it.", "rationale": "A model that cannot be lined up against existing standards, identifiers and practice cannot be adopted by anyone who already uses them.", "layers": [ { "id": "reported-evidence", "name": "Reported evidence", "description": "Findings from the breadth pass, kept separate from the structural claims.", "findings": [ { "id": "evidence-confidence-notes", "name": "Check these first", "description": "Recalled without web access and unsourced; every item is a lead to verify.", "evidence": [ "This entry covers the family of assembly languages, not a single architecture, assembler dialect or version.", "Syntax can vary within one architecture, as with Intel and AT&T syntax for x86; pseudo-instructions and macros also prevent a universal one-to-one correspondence between source statements and machine instructions.", "These statements are recalled knowledge, not researched findings; exact architecture revisions, assembler behavior and ABI applicability require verification." ], "questions": [ { "id": "evidence-confidence-notes-q01", "text": "Which of these check these first hold for the sense of assembly language this model covers, and on what evidence?", "kind": "provenance" } ] }, { "id": "evidence-kinds", "name": "Kinds and varieties", "description": "Recalled without web access and unsourced; every item is a lead to verify.", "evidence": [ "x86 assembly", "Arm assembly", "RISC-V assembly", "MIPS assembly", "PowerPC assembly", "6502 assembly" ], "questions": [ { "id": "evidence-kinds-q01", "text": "Which of these kinds and varieties hold for the sense of assembly language this model covers, and on what evidence?", "kind": "provenance" } ] }, { "id": "evidence-standards-and-regulation", "name": "Standards and regulation", "description": "Recalled without web access and unsourced; every item is a lead to verify.", "evidence": [ "RISC-V International's instruction-set specifications define the instructions and encodings targeted by RISC-V assemblers; they do not constitute a universal assembly-language standard.", "Arm's Application Binary Interface specifications define interoperability requirements, including procedure-call conventions, for assembly code that interfaces with other compiled code." ], "questions": [ { "id": "evidence-standards-and-regulation-q01", "text": "Which of these standards and regulation hold for the sense of assembly language this model covers, and on what evidence?", "kind": "provenance" } ] }, { "id": "evidence-real-world-use", "name": "Real-world use", "description": "Recalled without web access and unsourced; every item is a lead to verify.", "evidence": [ "Implementing processor startup code, interrupt handlers and low-level operating-system routines.", "Programming microcontrollers and other resource-constrained embedded systems.", "Writing selected performance-critical routines with direct control over instructions and registers.", "Inspectpecting compiled programs through disassembly for debugging and reverse engineering.", "Accessing processor features or instructions that a compiler does not conveniently expose." ], "questions": [ { "id": "evidence-real-world-use-q01", "text": "Which of these real-world use hold for the sense of assembly language this model covers, and on what evidence?", "kind": "provenance" } ] }, { "id": "evidence-failure-modes-and-hazards", "name": "Failure modes and hazards", "description": "Recalled without web access and unsourced; every item is a lead to verify.", "evidence": [ "Incorrect memory addressing can cause corruption, crashes or security vulnerabilities.", "Violating calling conventions, stack alignment or register-preservation rules can break interoperability.", "Instructions unavailable on the target processor can cause execution faults.", "Incorrect handling of concurrency, atomic operations or memory ordering can cause intermittent failures.", "Assembler syntax, directives and instruction-set differences can make source code nonportable." ], "questions": [ { "id": "evidence-failure-modes-and-hazards-q01", "text": "Which of these failure modes and hazards hold for the sense of assembly language this model covers, and on what evidence?", "kind": "provenance" } ] }, { "id": "evidence-neighbours", "name": "Neighbouring kinds and how to tell them apart", "description": "Recalled without web access and unsourced; every item is a lead to verify.", "evidence": [ { "name": "machine code", "difference": "Machine code consists of encoded instructions executed by a processor; assembly language expresses instructions symbolically in source text." }, { "name": "assembler", "difference": "An assembler is a translation tool; assembly language is the language it accepts." }, { "name": "instruction set architecture", "difference": "An instruction set architecture specifies software-visible processor behavior; assembly language provides a symbolic notation targeting that architecture." }, { "name": "high-level programming language", "difference": "A high-level language generally expresses computation through abstractions less directly tied to a particular processor's instructions and registers." }, { "name": "disassembly", "difference": "Disassembly is the process or output of decoding machine code into assembly notation, rather than the language itself." }, { "name": "natural language", "difference": "Assembly language is a formal programming language; speaker populations, vernacular varieties and natural-language identifier schemes do not describe it appropriately." } ], "questions": [ { "id": "evidence-neighbours-q01", "text": "Which of these neighbouring kinds and how to tell them apart hold for the sense of assembly language this model covers, and on what evidence?", "kind": "provenance" } ] } ] } ] } ] }, "openQuestions": [ "Does an existing Vercy world model already cover assembly language or its programming-language parent, requiring linkage or reuse rather than a second publication?", "Which documented dialects and assembler versions should serve as researched reference cases for this family-level model?", "How should the catalogue distinguish dialect identity from an assembler's selectable syntax modes and extensions?", "Should assembly-like languages for virtual machines fall within this entry, or be linked as neighboring language families?", "Which architecture manuals and assembler documentation establish authoritative boundaries among instruction aliases, pseudo-instructions, macros and directives?" ], "statistics": { "bundles": 6, "layers": 11, "findings": 16, "questions": 28 } }, "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 assembly language, record what state it is in, and decide what may be done with it.", "whatItIs": "Enable an agent to identify an assembly-language dialect, assess whether its source can be interpreted and translated for a specified target, and determine which modifications or uses are justified.", "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: ASSIRIS, inline assembler, Graphics Programming Language.", "3 finer distinctions are held as aliases rather than separate entries, because telling them apart needs a task that asks for it.", "Described in 86 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 assembly 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": [ "ASSIRIS", "inline assembler", "Graphics Programming Language" ] } ], "standing": "Described in 86 Wikipedia languages, which measures how widely it is written about rather than how important or how common it is. 3 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 assembly language from another, and a assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly language from the things most often confused with it.", "questions": [ { "id": "distinguishing-features-q01", "text": "What identifies and describes what distinguishes a assembly 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 assembly 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 assembly 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 assembly 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 assembly language between them.", "questions": [ { "id": "stages-and-transitions-q01", "text": "What identifies and describes the lifecycle of a assembly 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 assembly 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 assembly 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 assembly language, how often and by whom.", "findings": [ { "id": "observation-record", "name": "Observation record", "description": "How an observation of a assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly language contains and in what form it is held.", "questions": [ { "id": "content-and-format-q01", "text": "What identifies and describes the content of a assembly 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 assembly 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 assembly 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 assembly language and the period it survives.", "questions": [ { "id": "access-rules-q01", "text": "What identifies and describes access to a assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly 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 assembly language is written in and which spelling convention applies where.", "questions": [ { "id": "writing-systems-q01", "text": "Which scripts and orthographies are in use for assembly 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 assembly 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 assembly 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 assembly 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 assembly language and how confident it is.", "questions": [ { "id": "claim-provenance-q01", "text": "What identifies and describes a claim about a assembly 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 assembly 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 assembly 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 assembly language is retired without being erased.", "questions": [ { "id": "validity-and-supersession-q01", "text": "What identifies and describes the validity of a claim about a assembly 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 assembly 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 assembly 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 } } } }