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, concurrency, 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). |
| vector / matrix | The math value types with shape in the type: vector[N] of T, matrix[R, C] of T; a product whose dimensions cannot meet is refused at compile time. |
| dynamic array | The growable array under the value rule: Append and Length, and an assignment that copies — no callee can grow the caller’s list. |
| span | The borrowed view over a sequence: formed at a visible Span, never outliving the storage it names. |
| sequence families | The four shapes a run of elements comes in — fixed array, vector and matrix, dynamic array, span — under one reader vocabulary. |
| wide integer | The fixed-width family past 64 bits, int[N] / uint[N], published as int128 through uint256; converts only through the 64-bit bridge. |
| bigint | The unbounded integer of the integers unit: verb arithmetic, no promotion, no cast. |
| residency | Where a tensor’s storage lives: on gpu keeps the type and moves the value device-side; crossings are the visible ToDevice / ToHost. |
2 · Memory safety and the heap
The heart of Mica: 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. |
| memory class | The link-time choice of where memory comes from: the hosted heap or a fixed arena — the same source serves both. |
| fixed arena | One fixed block serving every allocation, with a budget that fails loudly at a named line instead of growing. |
3 · Concurrency and streams
| Term | Meaning |
|---|---|
| task | A concurrent activity started inside a concurrent block, whose end joins every task it started. |
| task tree | The tree of running tasks, which is the scope tree: a scope that ends takes its tasks with it. |
| carrier | An operating-system thread carrying tasks; how many is a build flag, and results do not depend on the count. |
| synchronized | The one keyword under which shared state may be touched; an unmarked shared touch is a compile-time error. |
| generator | A body producing values one at a time, suspending between them; its instance can be named, paused, and resumed. |
| stream | The typed conveyor between producers and consumers: pulled from a generator, or pushed over a bounded ring. |
| bounded ring | The fixed-capacity buffer behind a pushed stream, where fan-in and fan-out meet without a lock in user code. |
| select | The statement that waits on several stream arms at once, with an optional timeout arm. |
| concurrent | The block that opens a task scope; its end is the join no task escapes. |
| schedule | The statement that starts one task inside a concurrent block. |
| Yield | The cooperative suspension point: the running task offers the scheduler a chance to run its siblings. |
| cancellation | A failing sibling cancels the scope’s survivors; the pending flag is delivered at a suspension point and routes the body onto its early leave, defers included. |
4 · 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. |
5 · 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. |
6 · Platform and the C boundary
| Term | Meaning |
|---|---|
| contract | A JSON description of a C library that enables checked calls. |
| C ABI | The calling and layout convention through which Mica and C code link and call each other. |
| 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). |
7 · Tooling and quality
| 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. |
8 · Machine learning in the language
| Term | Meaning |
|---|---|
| autograd | Differentiation by recording: the program computes forward while the tape transcribes, and one backward walk assigns every knob its blame. |
| tracked value | The autograd knob: a pair of a value and its tape node id, declared tracked. |
| tape | The recording window: operations on tracked values inside tape … end append to one transcript per program. |
| Backward / Gradient | The reverse walk over a closed tape window, and the read of one knob’s blame after it. |
| recorded verb | A tensor operation that appends its reverse rule to the tape as it runs — Tanh, Softmax, the matrix product, and their family. |
| device residency | Tensor data living on the GPU: placement is a compile-time fact, and an operation that would silently shuttle between host and device does not compile. |
| layer verbs | The curated device vocabulary — RowSoftmax, LayerNorm, CrossEntropy, AdamStep, TanhMap — running as device kernels behind the same source spelling they have on the host. |
| formula tier | Greek letters, subscript identifiers, and the operators × and · as ordinary Mica spellings, so numeric source reads like the notation it implements. |
See also: the German edition and the Simplified Chinese edition of this glossary, and the technical portrait of Mica.