Mica is a systems programming language with clean, structured syntax and explicit
control over the machine. This glossary defines the core terms used across the
compiler — the language, the memory model, the pipeline, the backend, the platform,
and the tooling — so that writing and discussion about Mica stays precise.
These English terms are the canonical ones: the compiler’s keywords, error
messages, and identifiers use them. A German edition translates and explains the
same terms for German-speaking readers. This is a living document.
1 · Language and type system#
| Term | Meaning |
|---|
| compiler | Translates Mica source all the way down to native machine code. |
| systems programming language | A language with direct, visible control over memory and the machine. |
| statement | An executable step of the program (assignment, loop, and so on). |
| expression | A computation that yields a value. |
| declaration | The introduction of a name (constant, variable, type, function). |
| record | A composite type made of named fields. |
| field | A named member of a record. |
| array | An indexed collection of like elements of fixed size. |
| set | A mathematical set over an ordinal type; membership rather than bit masks. |
| enumeration | A distinct type with named, ordered values. |
| subrange | A type whose values are restricted to an interval. |
| generic / type parameter | A procedure or function parameterized over a type. |
| capability constraint | The requirement a type parameter must meet, named by capability words (ordered, numeric, equality, …). |
| ordinal type | A type with a finite, ordered, countable set of values. |
| domain (of a type) | The set of valid values of a type, with a lower and an upper bound. |
| lower / upper bound | The smallest / largest value of a domain. |
| pointer | Refers to a value at a memory address. |
| to dereference | Read or write the value a pointer refers to. |
| address-of | Take the address of a variable. |
| nil | An assignable, comparable pointer value that refers to nothing. |
| short-circuit evaluation | The right side of and/or is evaluated only when needed. |
| checked arithmetic | A mode that detects and reports integer overflow at run time. |
| overflow | A result outside the representable range. |
| signed / unsigned | Integer types with / without a sign. |
| floating-point | Real numbers per IEEE 754. |
| boolean | The type with the values false and true. |
| string | A sequence of characters; UTF-32 by default in Mica. |
| code point | A single Unicode character (32 bits). |
2 · Memory safety and the heap#
The heart of Mica 5.0.0: heap memory safety is proven at compile time by flow
analysis — no garbage collection, no borrow checker, and no lifetime annotations.
| Term | Meaning |
|---|
| heap | Memory for dynamically requested values with a free lifetime. |
| allocation | Requesting a cell on the heap (new). |
| to free / release | Make a cell available again (dispose). |
| obligation | Every allocation creates an obligation that must be discharged on every path. |
| to discharge (an obligation) | Satisfy an obligation — via dispose, by binding it to an owner, or by returning the pointer. |
| contract | The rule that every obligation must be discharged on every path; otherwise the program does not compile. |
| owner | Every allocation has exactly one owner at any moment; the owner’s end of life frees the memory. |
| ownership | Responsibility for freeing a cell. |
| owner-bound | An allocation whose release is bound to its owner’s end of life. |
| lifetime | The span over which a cell may be used validly. |
| lifetime class | One of four classifications of each allocation site (see the next four rows). |
| transferred | The obligation leaves the function through the return value; the caller carries it onward. |
| manual-verified | A dispose discharges the obligation on every tracked path — provably leak-free. |
| manual-unverified | The pointer escapes the analysis; the obligation is named but not enforced. |
| region | A per-owner arena: filled linearly, released in bulk when the owner exits. |
| region allocator | The allocator that implements a region: bump-allocate within it, then reclaim the whole region at once at the owner’s exit. |
| region-based memory management | Requesting memory in blocks and releasing it together rather than cell by cell. |
| obligation analysis | The dataflow analysis that classifies each allocation site and proves leaks. |
| garbage collection | A runtime technique that reclaims unreachable memory automatically — deliberately not used by Mica. |
| borrow checker | Rust’s type-based lifetime checking — replaced in Mica by flow analysis. |
| memory leak | Memory that is allocated but never freed. |
| silent leak | An unnoticed leak; in Mica, a fully-tracked leak is not expressible. |
| use-after-free | The erroneous access to already-freed memory. |
| double-free | Erroneously freeing the same cell twice. |
| dangling pointer | A pointer to memory that is no longer valid. |
| defer | Run a statement when the function exits — a cleanup guard. |
| escape | A pointer leaves the part of the program the analysis can follow. |
| provenance | Whether a pointer is Mica-owned or foreign (from C); disposing a foreign pointer is a compile error. |
| memory narration | The compiler’s per-allocation report: the owner, the proven lifetime class, and the chosen allocator. |
| allocator | The component that actually provides heap memory. |
| bump allocator / arena | Allocates by advancing a pointer; releases in bulk. |
| fixed arena | A statically budgeted memory area with no operating-system heap behind it — for embedded targets. |
| plug-in | An interchangeable allocator behind a fixed interface. |
| compile-time / runtime | During translation / during execution. |
3 · The compilation pipeline#
| Term | Meaning |
|---|
| scanner / lexer | Splits the source into tokens. |
| token | The smallest meaningful unit of source text. |
| parser | Builds the syntax tree from the tokens. |
| recursive descent | A readable parsing technique that follows the grammar. |
| abstract syntax tree (AST) | The tree representation of the program after parsing. |
| semantic analysis | Checks names, types, and rules; folds constants. |
| pass | A distinct analysis or transformation step. |
| constant folding | Evaluating constant expressions already at compile time. |
| lowering | Converting to a more machine-near representation. |
| intermediate representation (IR) | A flat form between the syntax tree and machine code. |
| three-address code | An IR form with at most three operands per operation. |
| Spectra | Mica’s intermediate language: a typed, three-address IR. |
| monomorphization | How generics compile: one concrete specialization is generated per distinct set of type arguments. |
| string fusion | A chained concatenation (s1 + s2 + s3) lowered to a single sized allocation, with no intermediate temporaries. |
| activation record / stack frame | The memory frame of a function call. |
| static link | The reference through which a nested function reaches its enclosing scope. |
| nested function | A function defined inside another. |
| scope | The region of the program where a name is visible. |
4 · Backend and code generation#
| Term | Meaning |
|---|
| control-flow graph (CFG) | The program as basic blocks and the edges between them. |
| basic block | A straight-line run of instructions with one entry and one exit. |
| static single assignment (SSA) | A form in which every value is assigned exactly once. |
| dominance / dominator | A block dominates another if every path to it passes through it. |
| dominance frontier | The places where φ-functions are inserted. |
| liveness | Which values are still needed at a given point. |
| live range | The span over which a value is live. |
| reaching definitions | Which assignments can reach a given point. |
| dataflow analysis | Techniques that compute program properties along the control flow. |
| inlining | Substituting a small function’s body at the call site. |
| register allocation | Assigning values to machine registers or stack slots. |
| graph coloring | A method of register allocation. |
| spill | Moving a value to the stack for lack of a register. |
| peephole optimization | Local improvements over a small window of instructions. |
| instruction selection | Mapping IR operations to machine instructions. |
| calling convention | The rules for passing arguments and returns. |
| ABI (application binary interface) | The binary interface that compiled programs adhere to. |
| executable | A runnable program (ELF). |
| static library / archive | A collection of compiled units meant for linking in. |
| shared object | A library loadable at run time. |
| debug information (DWARF) | Data that lets debuggers map source, types, and variables. |
| assembler / linker | The GNU tools Mica uses to produce the binary. |
| Term | Meaning |
|---|
| contract | A JSON description of a C library that enables checked calls. |
| interoperability | The smooth interplay of Mica and C code. |
| foreign function interface (FFI) | Access to other languages’ functions — in Mica, through contracts. |
| standard library | The bundled runtime and I/O essentials. |
| format string | The template for input and output; checked at compile time. |
| type fingerprint | A digest that detects type mismatches between compilation units. |
| cross-compilation | Building for a target architecture other than the host’s. |
| target | The operating system and instruction set being built for. |
| encoding | The character encoding of the target (UTF-32 or UTF-8). |
| Term | Meaning |
|---|
| test harness | The tool that compiles, runs, and checks every test case. |
| test case | A single check described by a manifest. |
| manifest | The description of a test case (sources, expected output). |
| regression test | A test that permanently locks in behavior once achieved. |
| quality gate | An internal check that controls the compiler’s own transformations. |
| stress test | A test with especially large inputs. |
| benchmark | A measurement for performance comparison. |
| retired instructions | Machine instructions actually executed — the deterministic performance metric. |
| wall-clock time | The elapsed real time of a run. |
See also: the German edition and the Simplified Chinese edition of this glossary, and the technical portrait of Mica.