Term

Abstract Syntax Tree - A syntax term describing object graphs which describe the meaningful attributes and behavior of expressions in a particular concrete syntax
Abstraction - The term for the process of by which an object is taken out of its context, so that a new context can be applied to it
Abstraction Inversion - A term for what happens when program designers try to build simple things on top of complex "primitives" instead of building the complex things on top of simple primitives
Abstraction Level - A term, informally denoting an ordering between different possible abstract representations of a common domain
Active - A term for objects which have side effects, otherwise objects are passive or pure
Actor - The term for a paradigm of programming which models computations with concurrent (possibly transparently-distributed) entities, the Actors, that communicate with asynchronous messages; Actors may update their behaviour depending on the messages they receive
Agent - A user interface term for a unit of migratable control that is often dedicated to a specific domain or class of tasks
Algebra and coalgebra - Algebra and coalgebra are terms used to describe some classes of mathematical structures which are commonly met in mathematics and in computer science
Animation - A user interface term for sequential display of graphics, intended to capitalize on the human visual ability to provide an understanding of the collection in a continuous form
Artificial Intelligence - A term with at least two intended meanings:
Aspect-Oriented Programming - The term for a means of metaprogramming where a programming language is separated into a core language and various domain-specific languages which express (ideally) orthogonal aspects of program behavior
Assembly - At the heart of computer is traditionally a piece of electronic circuitry that executes instructions in sequence, as fetched from memory where they are encoded in bit patterns
Aware - A term, the opposite of transparent
Bisimulation - A term that denotes a kind of relationship on the carrier of a coalgebra and which is dual to congruence
Bit - A term whose name is the contraction of "binary digit", is the maximal amount of information of a system that has two possible states (which maximum is reached when the two states are equally probable)
Bootstrap - A term for the issue of, or for a specific technique for, bringing a system in a desired state by means of a (simple, rough, ad-hoc) subsystem which can perform the task with no external aid, and which is usually discarded as the global desired state has been reached
Bus - The term for a shared communications medium, derived from the common usage of the term in computer architecture jargon
Buzzword - A term describing other terms used to make sentences longer and more ambiguous; in this respect they strictly oppose jargon
Capability - A security term describing a way of controlling access dynamically in a computing system by treating access to objects as provided by a "key" instead of via an "ID Card" (user rights)
Category Theory - The term for a very abstract (often too abstract for most) theory in mathematics relating several fields through some common properties
Centralized - The term for systems that exhibit a centralization pattern
Channel - Channel is a term for a structure through which data is sent from one object to another
Client - A term related to centralization
Code Generation - The term for the last phase of a compiler that emits code in the target language
Collection-Oriented - aka data parallel: the term for a paradigm of programming that involves operations on entire collections and avoids loops
Combinator - A term commonly used in functional programming languages to indicate a class of higher-order functions accepting other functions as inputs
Communication - The term for transfer or flow of information
Computing System - A term for a system that allows men to do computations
Computing World - The term for the concept encompassing all computers in the world, that are considered as being running different versions of a common Operating System, and linked to a global network
concatenative - The term for a sub-paradigm of programming in which function composition is rendered syntactically as concatenation (composition, juxtaposition) of symbols by means of a composition operator, usually rendered as a blank space
Concurrency - The term for the property of some collection of active processes that allows them to be active at any time, including at the same time, or in varying orders
Concurrency-Oriented - A term describing a programming language paradigm where independent parts of the problem can be represented as independent computations
Concurrent - The term for a programming language which directly supports concurrency within its core semantics, unlike for example C and C++ where concurrency must be provided by a library
Configuration - The term for a meta-object representing some "state of affairs": requirements on the relationships between some collection of objects
Congruence - A term that denotes a class of relationships between algebras and which is dual to bisimulation
Constraints - The term for a paradigm related to logic or declarative programming, where information is specified as a constraint on the result, and the evaluator's task is to use this information to limit the search space that some base set of algorithms would ordinarily have traversed to find the answer
Constructor and Destructor - In computer terminology, a constructor is some function that takes a list of parameter objects and makes a new object out of these by assembling them into a structure
Context - The term for that which gives, or completes, the meaning of an object
Continuation - A term from functional programming where a function is used to capture the whole of the rest of the computation from a specific point in the lexical scope
Correctness - A term describing a relation: a program is said to be correct with respect to some specification if it fulfills all the constraints of this specification
Cybernetics - A term for the science of information, that is, of what makes dynamical systems and meta-systems
Decentralized - The contrasting term to centralized: not obeying to a one guide, chief, führer, duce, central committee, or any other kind of grand beloved all-mighty all-knowing (individual or collective) leader
Declarative - The term for a paradigm of programming where the specification allows for a great deal of freedom in acheiving results as specified; we say that a declarative program specifies the "what" of the result, but not the "how"; programming languages which encourage this style of programming are termed declarative, and specifically include the logic and functional paradigms, to varying degrees
Dependent Types - A term describing a type system where types can depend on values
Design Pattern - A term for describing how a solution framework is often not supported by underlying programming languages
Diagram - A user interface term for a representation of some group of information that at least partially makes use of structural or symbolic representation
Dispatch - The term and topic of a programming language's method of choosing a definition to use to evaluate some expression
Distributed - A term describing a networked computer system which is able to dynamically dispatch information around the whole network of available workstations or subsystems, automatically, according to demand
Domain-Specific Language - The term for a programming language designed for a special purpose, usually within some commercial field of application, although such a language can be made for practically any domain
Duality - The term for a dichotomy or a division in a space of possibilities
Dynamic - A term which applies to what possesses Dynamism
Dynamic Compilation - The term for the dynamic construction of code while other code in the same system is being evaluated
Dynamism - The term for the notion according to which the world constantly changes and evolves, and that no static analysis can be indefinitely valid
Efficient - A term generally used to mean fast, optimized, or non-wasteful when referring to programs, algorithms, or programming languages (if it has low overhead)
End-Users - According to the silly notions of traditional systems, a term for some category of people, for whom computers would be made, but who for whatever reason would not learn about the technical details in any manner
Entropy - The term for the opposite of information
Epsilon Calculus - A formal logic term
Equality - The term for a relation among objects within a given context determining their comparitive identity - whether they are the same or different from a given perspective
Escape - A term for a way to exit the current or normal context
Expressiveness - A term for a comparative quality of a language:
Fault-tolerant - The term for the ability of a system to continue normal operation despite the presence of hardware or software faults
Feature-Oriented Programming - The term for a kind of metaprogramming
Feedback - The term for the mechanism by which information can stabilize, propagate, and evolve in a dynamic system: subsystems correct their output according to the input they get back from the "external world" after
File System - The term for a low-level programming model for persistent data storage
First-Order - The term for contexts in which only objects of a theory may be abstracted
Foreign Function Interface - The term for the means for a language to access code written in other languages (see Combining Languages)
Functional - The term for a paradigm of programming that originates in the early works about lambda calculus: computations consist in evaluating/expanding structured expressions, rather than executing instructions, as with imperative programming
Future - The term for a place-holder for the undetermined result of a (concurrent) computation
Garbage Collection - The term for automated memory-management and reclamation, one of the many methods of migration
Grain - A term for the minimal or typical size of objects a system can handle
Graph Reduction - A technical term, taken from its FOLDOC entry:
handshaking - A term describing a simple synchronization scheme between two connected objects (programs, devices, or computer systems), which is usually designed to ensure that the two objects 'take turns' at communicating with each other
Hardware-Independent - A comparative term for software which has a higher abstraction level with respect to the underlying hardware
High-Level - A term describing a comparatively-suitable end of a spectrum of abstraction levels for the context that requires the abstractions
Higher-Order - The term for a context in which any kind of abstractions are recursively possible over a system
highly concurrent - A term for a program or system whose software is designed to execute as a relatively large number of threads, so as to interact more efficiently with the outside environment (the user, I/O devices, other software or system components)
Host - A standard term for the basic entity in a computer network: each computer in the network is typically called a "host"
Hypertext - A user interface term coined by Ted Nelson to discuss text as a medium extended to support any kinds of internalized references to other pieces of text
Imperative - The term for a paradigm of programming that involves (mostly unconstrained) update of the state of a machine through direct instructions
Induction and Co-induction - These are contrasting terms for ways of describing a system
Information - A term for the measure of the improbability of the known state of a system
Initiality and finality - These terms indicate dual concepts in category theory
Input - A term for what is consumed by an open system
Interoperability - The term for a number of different entities being able to speak the same language
Isolation - A term for when a computer object is not secure, it must be isolated from possible sources of failure
Jargon - Jargon are a collection of terms that have a precise meaning in a given technical or cultural context, and that help people of a given milieu communicate in a precise and concise way
Kernel - The term for any "central" part in a software program
Lambda Calculus - The term for the mathematically formalized theory of abstractions
Language - The term for a medium of expression, which consists of a vocabulary, some semantics, and a syntax for accessing the semantics
Language-Based Security - The term for an approach to security which relies on the properties of a programming language in which programs are written to ensure that promises are not violated
Lazy Evaluation - The term for a strategy to evaluate objects only when one is sure they are useful or needed, and not before
LifeStreams - A user interface term: it is a stream of information chunks to organize the way a person deals with other people; in much the same manner as an electronic diary, the chronological arrangement is key, but the information can be organized in many other ways
Linear Algebra - In any generalized algebra, that is, a structure with a commutative associative sum operation with neutral element over which other "product" operations distribute, a functional term is said to be linear in some variable if and only if this term can be expressed as a sum of "monomials" in each of which the variable appears (exactly) once
Linear Graph Reduction - The term for a variation on traditional graph reduction where the availability of references obeys a linear logic in its type
Linear Logic - Linear Logic, which started as a theoretical endeavor in proof theory, is now a theme of study of its own
load balancing - A term describing any mechanism for automatically redistributing computational work (the 'load') among available processing resources, so that better (or the best) use is made of those resources
Logic - The term for a paradigm of programming that originates in the Curry-Howard Isomorphism, which relates types and proofs to terms and expressions
Low-Level - A term for contexts that are less adapted to a problem in the context of abstraction levels
Macro - The term for a way to extend the syntax and semantics of a programming language; they are a special case of compile-time rewrite
Man - The term for some fragile machine that takes several tens of years to manufacture, with a low success rate, and only seconds to get definitely out-of-order
Marshalling - The term for encoding high-level data-structures so they fit the sequence-of-bytes (or sequence-of-words) paradigm used in low-level message-passing paradigms
Memory - The computer term for the maximum amount of information it can handle, as measured in bits
Meta- - A prefix term that means beyond or after (spatially)
Meta-Circular - A term describing an interpreter for a language L written in the same language L (or a subset thereof), said to be a meta-circular interpreter
Meta-Level - The Meta-level is a relative term for any object, describing the level of discourse about that object; the objects of the metalevel (or metaobjects) are sentences or programs that are used to describe and manipulate objects at the original ("base") level
Meta-Object - The term for an object whose sole focus of attention is another object
Meta-Object Protocol - A term for, simply stated, a set of rules for manipulating and communicating with meta-objects
Meta-Space - An object is defined in a space, in a context
Meta-System Transition - The term for a theory being settled down by the
Metaprogramming - Meta-programming is the term for the art of developing methods and programs to read, manipulate, and/or write other programs
Metatext - A term coined within the Tunes Interfaces subproject for the use of higher-order objects to deal with and relate hypertext systems
Microkernel - Microkernel (also abbreviated µK or uK) is the term describing an approach to Operating System design by which the functionality of the system is moved out of the traditional "kernel", into a set of "servers" that communicate through a "minimal" kernel, leaving as little as possible in "system space" and as much as possible in "user space"
Microkernel Debate - This is a debate on Microkernels
Migration - The term for the phenomenon whereby the representation for an object is changed while conserving the abstract object consistently unchanged
Modal - Modal is a user interface term, but it is applied from the field of logic, where a mode means a situation where only a finite set of possibilities for transitioning into the future are possible
Module - A term for a component of a system with a well-defined interface
Monad - A term taken from category theory and applied to functional programming concepts to provide a way to deal with local, single-thread state in a functional language without having to pass the state around explicitly as extra arguments to all the functions that deal with it (and requiring changing their signatures, etc.) See also Eugenio Moggi and a Learning Lounge course, Monads 101
Morphism - A term related to category theory describing a map between two objects in an abstract category
Network - The term for a system all of whose members are networked
Networked - For an entity in a system, the term for being linked to other entities, that is, there being input and output between the entity and others, faster than the speed that the entity can stabilize
No-Kernel - A term describing a system without a kernel
Non-Well-Founded - A term for systems that are not well-founded, meaning that they are not based strictly on a few independent principles
Object - A unified term to manipulate computer abstractions
Object-Oriented - A paradigm of programming
Ontology - In philosophy the term ontology is used to indicate a theory of being, which describes "what is" and in some cases by converse "what is not", and the relationships between beings
Open Implementation - The term for an implementation that can be dynamically (at run-time or otherwise post facto) evolved, customized, modified, etc
Operating System - In the TUNES project, the term for any common cultural background between different computers
Optimize - In the commercial jargon, the term "to optimize" means to make better, quicker, smaller, less expensive, more efficient
Optimizer - The term for optimizing code generation
Orthogonal - A term: we say that A is orthogonal to B if you don't have to think about feature A while thinking about feature B
Orthogonal Persistence - The term for a system's property in which objects persist until they are no more needed, neither before, which would make the system fail, nor after, which would waste (eventually all) the system's limited resources
Output - The term for what is produced by an open system
Overhead - The term for unproductive expense
Paradigm - A term for a way of exposing concepts and things; see also Programming Languages for a list of programming paradigms
Parsing - The term for the process of turning an input stream into an abstract syntax tree
Partial Evaluation - A term for the metaprogramming technique that consists in program transformation into simpler programs specialized for execution in an environment where some information is known as compared to a generic environment
Passive - A term for objects which are not active
Pattern-Matching - A term used to describe a family of programs operating over compound, structured data, usually trees or graphs
Performance - The term for the inverse of the quantity of resources consumed by a computation, as defined by some metric
Persistence - A term for a system in which any object consistently preserves its informational content across some expectable stressing modification, and more generally accross all the modifications that time is likely to bring
Portability - The term for a system or object describing the fact that communication is as easy as possible for it
Process - The term within traditional operating systems for a very coarse-grained active object
process migration - A term for the ability of a distributed operating system to move processes from one workstation or subsystem to another around the network, automatically, according to demand
Programming Language - A topic for programming languages, a term for computational languages that are at least as expressive as the lambda calculus
Proof - A term for the process of checking that a belief holds in some context
Proof-Carrying Code - The term for a type of program or module that carries a verifiable specification of its behavior as it is migrated between contexts
Protection - The term for a common low-level paradigm for security, in
prototype-based - A term describing an object-oriented sub-paradigm, which contrast class-based
Pure - A term for actions or things with no side effect
Quine - The term for a sentence that describes itself
Quotienting - A term from logic for a type of abstraction which takes a class of objects according to some set of rules, providing new identities for objects that are identical according to those rules
Rational - The term for that which relies on and trusts reason, acknowledges the truth that reason reveals, but also acknowledges the limits of what reason can reveal
Real-Time - Real time is a term that pertains to the responsiveness of a system wich is sufficiently immediate or that enables it to keep up with some external process
Reference - The term for an abstraction of the use of an object
Referential Transparency and State - A pair of terms characterizing two useful ways of looking at a computing system:
Reflection - Etymologically, reflection is first a term about turning back the image of another object; since the phenomenon was mostly used to see oneself with mirrors (the alternate spelling reflexion is preferred for the optical phenomenon), it has come to mean applying to oneself (see reflexive)
Reflective Tower - The term for a chain of meta-levels or meta-system transitions which at some point enters a recursion possibility
Reflexive - While having same etymology as Reflection, the term Reflexive means to apply or to refer to oneself
Reification - Reification is the term for an operation by which something that was previously implicit, unexpressed and possibly unexpressible is explicitly formulated and made available to conceptual (logical or computational) manipulation
Relational - The term for a paradigm of programming where relationships between objects are formalized as Relation objects
Resilient - The term for resistant to problems and surviving failures
Rewrite - The term for replacement of strings, terms, trees, or other forms of expression according to logical rules, particularly as a form of evaluation semantics
Run-Time Code Generation - The term for code generation by a running program (run-time)
Scope - The term for a concept abstracted from the lexical or dynamic scope concept in most programming languages
Security - Security is the term we take as the dual concept of liberty: while liberty is potential information, security is actual information
Self-extensible - The term describing a cybernetic system that is powerful enough to accomplish some kind of meta-system transition: a way to abstract from some issue in a system-wide scope
Semantics - The term that applies in various ways to describe what the programs of a language mean
Sequential Machine - The term for the usual way to conceive single units of computations, as modelled by Von Neumann in the 1940's
Serializing - The modern term for Marshalling
Server - In a centralized organization, the term for the central (commanding) entity, which responds to requests for information
Side Effect - A term: an operation is said to have side effects if it modifies the context in which it is executed
Static - A term for an object that doesn't move or change, that is, is not dynamic
Statism - The term for the notion that the world is essentially static, that is, doesn't change significantly
Super-User - The term for human users who are given all the power on the system, in some system-management policies
Syntax - The term and topic of the structure of expressions in a language
Tactic - A term derived from Coq's usage of it meaning a program which operates on a declarative system in a procedural manner
Terminal - The user interface term which, for the purposes of Tunes, is the combination of any output device and any input device
Thread - In Tunes, the term for any kind of object that can be considered semantically as a logical unit of execution, from a light-weight continuation being evaluated to a number of coarse-grained unixish processes, including interrupt handling code, etc
Time-Machine Computing - A user interface term for a time-centric approach to organizing information on computers; it differs from LifeStreams in the use of both time and spatial (2D desktop) dimensions (where for LifeStreams the spatial dimension is not meaningful, it is automatically managed)
Transparent - A term indicating a feature of a software component whose behavior, i
Trust - When there's some statistical likelihood based on observations alone, then when the subject acts on the information that's just statistically-likely, then we use the term that the subject is trusting that the information is the case
Type - Typing in general means that the choice of possible data structures manipulated by a program can be conceptually divided into groups of objects with some homogeneity (e.g. integers, floating-point numbers, lists, arrays, hash-tables, etc.); the term for these groups is called a type
Type System - Programming languages usually come with a type-system, a term for some algebraic structure whose elements are the types of data that can be manipulated in the language, together with a mapping from the set of objects involved in defining the semantics of the language into the typesystem
Unification - A term generalizing that of pattern-matching that is the logic programming equivalent of instantiation in logic
Unified - Our term for the notion that all computer abstractions are equal, and may equally be subject to any operation, without any arbitrary prejudice or discrimination, including "code" vs "data", or "persistent" vs "transient"
Uniform - A term which applies to what is unified
User - The term for someone who uses a computer or a piece of software, or whatever, in any way
User Rights - Traditional systems enforce a "security" paradigm of a finite number of users, each controlling his own files, and having no right (a semi-legal term) on those from others
Utilitarianism - Utilitarianism is the term for a philosophy that places an absolute concept of Utility, (relatively to some notion of Good), as ultimately the only direct or indirect moral end
Utility - We say that something is useful if and only if it improves the world
Version-Aware - This term expresses that a system where multiple and concurrent modifications of an object can be expressed as their own unique objects
Virtual Machine - The term for a machine (computing system) that is designed for and intended to be used only as software within another machine
Visible - Visible is a User Interface term
Well-Founded - A term for systems that are built inductively, starting from a small core and calling constructors on it
World - A term for any system considered closed

Pages in this topic: Abstract Syntax Tree Abstraction Abstraction Inversion Abstraction Level Active Actor Agent Algebra and coalgebra Animation Artificial Intelligence Aspect-Oriented Programming Assembly Aware Bisimulation Bit Bootstrap Bus Buzzword Capability Category Theory Centralized Channel Client Code Generation Collection-Oriented Combinator Communication Computing System Computing World concatenative Concurrency Concurrency-Oriented Concurrent Configuration Congruence Constraints Constructor and Destructor Context Continuation Correctness Cybernetics Decentralized Declarative Dependent Types Design Pattern Diagram Dispatch Distributed Domain-Specific Language Duality Dynamic Dynamic Compilation Dynamism Efficient End-Users Entropy Epsilon Calculus Equality Escape Expressiveness Fault-tolerant Feature-Oriented Programming Feedback File System First-Order Foreign Function Interface Functional Future Garbage Collection Grain Graph Reduction handshaking Hardware-Independent High-Level Higher-Order highly concurrent Host Hypertext Imperative Induction and Co-induction Information Initiality and finality Input Interoperability Isolation Jargon Kernel Lambda Calculus Language Language-Based Security Lazy Evaluation LifeStreams Linear Algebra Linear Graph Reduction Linear Logic load balancing Logic Low-Level Macro Man Marshalling Memory Meta- Meta-Circular Meta-Level Meta-Object Meta-Object Protocol Meta-Space Meta-System Transition Metaprogramming Metatext Microkernel Microkernel Debate Migration Modal Module Monad Morphism Network Networked No-Kernel Non-Well-Founded Object Object-Oriented Ontology Open Implementation Operating System Optimize Optimizer Orthogonal Orthogonal Persistence Output Overhead Paradigm Parsing Partial Evaluation Passive Pattern-Matching Performance Persistence Portability Process process migration Programming Language Proof Proof-Carrying Code Protection prototype-based Pure Quine Quotienting Rational Real-Time Reference Referential Transparency and State Reflection Reflective Tower Reflexive Reification Relational Resilient Rewrite Run-Time Code Generation Scope Security Self-extensible Semantics Sequential Machine Serializing Server Side Effect Static Statism Super-User Syntax Tactic Terminal Thread Time-Machine Computing Transparent Trust Type Type System Unification Unified Uniform User User Rights Utilitarianism Utility Version-Aware Virtual Machine Visible Well-Founded World

Also linked from: CLiki Bugs CLiki Content Glossary Linda Review Site Map Text Formatting User Interfaces