Programming Languages & Runtime Types

← Back to Domain-Specific Families

Abstractions about programming-language levels, types, methods, operators, execution representations, and runtime failure. They include bytecode and assembly, exception and null handling, parametricity, probabilistic and set-theoretic programming, compilers, virtual dispatch, and structural typing.

21 abstractions in this family — domain-specific abstractions that sit near one another in structural-signature space (k-means over structural-signature embeddings). Each is shown with its short description.

• Bytecode — A compact intermediate instruction representation designed for execution or translation by a software virtual machine.
• Exception handling — The controlled transfer of execution from an anomalous condition to a designated handler that can recover, translate, propagate or terminate.
• High-level programming language — A programming language that lets programs express algorithms through abstractions substantially removed from processor instructions, registers, raw addresses and other machine details.
• Increment and decrement operators — Unary programming operators that increase or decrease a mutable operand by one, with prefix and postfix forms differing in the value yielded by the expression.
• Method (computer programming) — A callable procedure associated with a class or object whose dispatch and access to receiver state express that object's behavior.
• MPS (format) — A line-oriented interchange format for representing linear and mixed-integer optimization models through named rows, columns, coefficients, bounds, and integer markers.
• Null pointer — A distinguished pointer or reference value guaranteed not to designate any valid object.
• Parametricity — The uniformity principle that a parametrically polymorphic program must behave relationally the same at every type instantiation because it cannot inspect the abstract type.
• Probabilistic programming — A programming paradigm that specifies generative probability models as programs and delegates posterior inference to a general inference engine.
• Programming language — A formal engineered language whose syntax and semantics express computations for execution, translation or analysis by an implementation.
• Python (programming language) — A general-purpose, high-level programming language with significant indentation, dynamic typing, automatic memory management, a large standard library, and multiple implementation ecosystems.
• Relational operator — A programming-language operator that compares two operands under a specified relation and returns a truth-valued result.
• Semantic analysis (compilers) — The compiler phase that checks context-sensitive program meaning and annotates parsed syntax before intermediate-code generation.
• Set theoretic programming — A programming paradigm that treats sets, relations, mappings, and high-level set operations as primary data and control abstractions.
• Structural type system — A static type discipline in which compatibility or subtyping is determined by the members and shapes a value provides rather than by declared type names or ancestry.
• Tom (programming language) — A language extension for C and Java that adds algebraic pattern matching, term construction, rewrite rules and programmable rewriting strategies.
• Turing tarpit — A computationally universal language or interface whose lack of useful abstractions makes ordinary tasks disproportionately difficult to express and maintain.
• Type signature — A formal declaration of the input types, output type, and sometimes constraints, effects, or calling structure of a program entity.
• Typed assembly language — A low-level instruction language augmented with machine-checkable types for registers, memory, code pointers, stacks and heaps, allowing native code to carry a static proof of specified safety properties.
• Virtual class — An object-oriented language feature whose nested member class can be overridden so its runtime identity varies with the enclosing object’s dynamic type.
• Virtual function — An overridable object-oriented method whose implementation is selected at runtime from the actual receiver type.