.Open Glossary of Computer Language Terms To find the definition of a term search for the term followed by two colons(:). Also see general set of reference documents: .See http://www.csci.csusb.edu/dick/info4.html#Ref For acronyms and abbreviations, please see ikind@mcimail.com's .See http://www.access.digex.net/~ikind/babel95b.html For methods: .See http://www.csci.csusb.edu/dick/methods.html For particular languages: .See http://www/dick/samples/ada.glossary.html .See http://www/dick/samples/c++.glossary.html .See http://www/dick/samples/comp.html.glossary.html .See http://www/dick/samples/java.html#Glossary .See http://www/dick/samples/objects.glossary.html .See http://www/dick/samples/prolog.glossary.html and .See http://www/dick/samples/smalltalk.glossary.html . A Thru Z Ada::=`Programming language dedigned for programming embedded applications`. Ada::=Ada83 | Ada95. .See http://www/dick/samples/ada.glossary.html ADT::=`Abstract data type`. ADT::=$data_type with `hidden $implementation details`. ADT::abreviation="Abstract Data Type". ASCII::=`The original common character code for computers using 8 bits`. .See http://www.csci.csusb.edu/dick/samples/comp.text.ASCII.html BASIC::="Beginners All-purpose Symbolic Insctruction Code", a family of languages developed for teaching programming and given away with early IBM PCs. BNF::=`Backus Naur Form. An old version of a popular way to define syntax of programming languages`. Also see $EBNF and $XBNF. Boolean::adjective=`Any data type that follows George Boole's algebraic axioms`. The commonest Boolean data has two values {true, false} and the operations of and, or, and not. .See http://www/dick/maths/math_41_Two_Operators.html#BOOLEAN_ALGEBRA C::=`Programming Lnaguage invented to help develop operating systems. C::= "K&R C" | ANSI_C. .See http://www/dick/samples/c.glossary.html C++::=`Hibrid child of C with object oriented features and $generic fuunctions and classes`. C++::=`BJarne Stroustroup's C++` | `ANSI/ISO_C++`. .See http://www/dick/samples/c++.glossary.html CLOS::="Common LISP Object System`, a modern $LISP. COBOL::=`COmmon Business Oriented Language`. EBNF::=`Extended BNF. A popular way to define syntax as a dictionary of terms defined by using iteration, options, alternatives, etc`. [ $BNF ]. FORTRAN::=`FORmula TRANslation`. There have been many FORTRANs. The series includes: I, II, IV, 66, 77, and 90 so far. Its author has said that he doesn't know what the programming language used in the next millenium will look like but he's sure it will be called FORTRAN. HTML::=`HyperText Markup Language`. -- used to define pages on the WWW. HTML::=HTML_1 | HTML_2 | HTML_3 | ... . .See http://www/dick/samples/comp.html.glossary.html Java::=`Object oriented language that has a C-like syntax`. Java::=`a language for consumer boxes` | Java_0 | Java_1.0 | ... .See http://www/dick/samples/java.html#Glossary LISP::=`LISt Processing language`, The key versions are LISP1.5, $CLOS, and $Scheme. .See http://www/dick/samples/lisp.html PL::=`Programming Language`. Prolog::=`PROgramable LOGic`. .See http://www/dick/samples/prolog.glossary.html Scheme::=`a modern statically $scoped version of $LISP`. UML::="Unified Modelling Language". .See http://www/dick/samples/uml.html UNICODE::=`a new 16 bit International code for characters`. Used in $Java. .See http://www.unicode.org XBNF::MATHS=`An extension to EBNF invented by Dr. Botting so that ASCII can be used to describe formal syntax and semantics`. [ $EBNF ]. . a, b, c, d abstract::mathematical=`algebras and logics that describe several different concrete algebras and logics`. abstract::software_engineering=`descriptions that do not swamp you with unnecessary detail -- they provide enough information to use something without knowing its detailed construction`. active::=`A piece of code is active if the CPU is currently executing instructions in the code. Contrast with suspended`. actual_parameter::=`Any $parameter in the $call of a $subprogram`. algebra::=`A shorthand for calculations that can be used to solve some problems`. algorithm::=`A description in precise but natural and mathematical language of how a problem is solved`. alias::=`Two names or identifiers are aliases if they name or identify the same thing`. argument::English=`A heated discussion`. argument::logic=`A set of premises connected by correct deductive steps to one or more conclusions`. argument::C=parameter. .See parameter arithmetic_operations::=`addition, subtraction, multiplication and division ideally forming an $ADT with the algebraic properties of a ring or field`. .See [Hoare 69] array::data_type=`Each array associates each value of one data type with a unique object of another type` assignment::statement=`A statement with an expression and one or more variables. The expression is evaluated and the result is stored in the variables`. Most languages have assignments but the syntax varies form one to another. associative::math=Algebra with S:Sets & +:infix(S,S,S) & For all a,b,c:S( (a+b)+c = a+(b+c) ). associativity::=`rules for determining which of two identical infix operators should be evaluated first`. bind::=`to create a $binding`, binding::=`A relationship between two things, typically an identifier and some one of its properties or attributes`. For example a variable is an identifier bound to a piece of storage in the main memory of the computer. binding::= $static_binding | $dynamic_binding | $late_binding. bindings::=plural of $binding. binary::=`pertaining to 2`. Binary operators have two operands. Binary numbers have base 2 and use 2 symbols. Here are the first few binary integers .Table Binary Decimal .Row 0 0 .Row 1 1 .Row 10 2 .Row 11 3 .Row 100 4 .Row 101 5 .Row ... .Close.Table bit::=`$binary digit`. A unit of information introduced by Shannon in the 1940's. A bit has one of two values traditionally named 0 and 1. Eight bits make a byte. and four bits a nibble. So 2 nibbles = 1 byte. block::program_structure=`A piece of source code that has one or more declarations in it`. bool::C++=Boolean boolean::=`mispelling of $Boolean`. Since the word comes from a person's name it is correct to use the capital letter and impolite to use lowercase. bound::=`result of $binding`. btree::=`one of any number of more or less Ballanced $tree structures that offer moderately efficient seaching and updating of ordered data`. Poular and Ubiquitous. byte::=`eight bits`. call::=`A piece of code that transfers control, temporarily, to a subprogram and suspends the original code until the subprogram returns to the following statement etc`. call::=`to make use of something by writing its name and the correct protocol`. call_by(X)::=`oldfashioned way of saying: pass_by(X)`. ccc::=`ccc.h is a C++ $header_file created by Cay Horstman for teaching C++ that we use in out CS1/CS2 courses. A copy has been downloaded onto our CS201/CS202 machines and the lab instructions show how to use it.`. .See http://www.horstmann.com/ccc.html chain::data_structure=`any kind of $linked_list, a set of records where each record identifies the next record in some sequence or other`. class::=`a description of a collection of objects that have similar states and behaviors`. code::noun=`a piece of text that can be understood without a key, hence any program` coercion::=`an implicit type conversion that lets a smart compiler work out the wrong meaning for a programmers typing mistake`. compile::verb=`translate source code into executable object code`. compiler::= lexer ->- parser ->- generator ->- optimizer ->- linker. component::syntactic=`a part of a compound statement or object`, component::technology="a unit of composition with contractually specified interfaces and only explicit context dependencies", -- components can be deployed and composed by third parties, often a collection of objects with a given set of methods for handling them and abstract classes that can be defined by other people. compound::=`a single statement or object that can have any number of other statements as its parts`. conditional::=`an expression or statement that selects one out of a number of alternative subexpressions`. conditional_expression::=expression with condition:boolean_expression & e1:expression & e2:expression & if value(condition)=true then value=value(e1) & if value(condition)=false then value=value(e2). control_statement::=`statements that permit a processor to select the next of several possible computations according to various conditions`. coroutine::=`a named piece of code that can be restarted by another coroutine and vice versa. The simplest form of psudo-concurrency`. data_type::=`A collection of values together with the operations that use them and produce them, plus the assumptions that can be made about the operations and values`. data_type::=$structure | $enumerated | $primitive | $array | file | $pointer | ... . data_type::formal=Net{ Values::Set, Operations::@(%Values->Values), Assumptions::Finite_set(well_formed_formula) }. declaration::= variable_declaration | constant_declaration | type_declaration | subprogram_declaration | ... . declaration::=`A piece of source code that adds a name to the program's $environment and binds it to a class of meanings, and may also define the name`. default::=`An item provided in place of an omitted item`. define::=`What a definition does`. definition::=`A piece of source code or text that binds a name to a precise "definite" meaning. A definition may implicitly also declare the name at the same time or $bind more information to an already defined name`. delimiter::=`A symbol or character that indicates where something else begins or ends`. descriptor::=`A place that stores the properties of variables when a program is compiled or interpretted`. dictionary::=`Any set of definitions`. dynamic::=`something that is done as the program runs rather than by the compiler before the program runs`. dynamic_binding::=`A binding that can be made at any time as a program runs and may change as the program runs`. dynamic_chain::=`a $chain of activation records where each record identifies the activation in which it was called`. dynamically_scoped::=`something that uses $dynamic_scoping`. dynamic_scoping::=`determining the global $environment of a subprogram as that which surrounds its call`. dynamic_polymorphism::=`A kind of polymorphism where the current type of an object determines which of several alternate subprograms are invoked as the program runs`. dynamic_type_binding::=`When the type of a variable is determined at run time -- only applies to pointer variables which can refer to objects of different types`. dynamic_chain::=`a $chain of activation records where each record identifies the activation in which it was called`. . e,f,g,h encapsulated::programming=`coding that can be changed with out breaking client code`. encapsulated::Sebesta=`being able to place all relevant information in the same piece of code -- for example data and the operations that manipulate it in a C++ class`. encapsulation::programming=`The ability to hide unwanted details inside an interface so that the result works like a black box or vending machine - providing useful services to many clients(programs or people)`. enumerated::data_type=`data defined by listing its possible values`. environment::=`the environment of a statement is the set of bindings that hold for that statement as determined by $scoping rules and the execution of the program upto that statement`. equation::mathematics=`A formula stating the equality of two or more formula which may be true if the correct values of the variables are found`. erroneous::Ada=`A program whose result depends on the particular implementation used, rather than the meaning of the language`. exception::=`a mechanism for handling abnormal situations`. expression::=`A shorthand description of a calculation`. .See mathematical_expression expression::=part_of_a_program with value:data. expression_of_type(T)::=expression with value:values(T). fixed_point::=`A form of arithmetic that always has the same number of places on either side of the decimal point giving bounded rounding errors, speed, simplicity, and a comparatively small range'. Contrast with $floating_point. floating_point::=`A form of arithmetic that always preserves the same number of digits but allows the decimal point to be placed anywhere among them. This gives unbounded errors, a wider range and a more complex processor`. formal::=`something that is abstract or mathematical` | $formal_parameter | `a process that has more or less well defined rules`. formal_parameter::=`The symbol used inside a $subprogram in place of the $actual_parameter provided when the $subprogram is called`. .See call forward_reference::=`An identifier that is used before it is defined or (sometimes) declared`. Some languages require that all identifiers are defined before they are used and so a forward reference is an error in these languages. Some languages - Pascal -- require that forward references are given a special declaration. Other languages (C for example) assume a set of default attributes for a forward reference... causing an error when the real declaration appears. C and C++ prototypes first appeared as a way to allow an identifier to be used without its full definition being available. function::Ada=`A subprogram that returns a value but can not change its parameters or have side effects`. function::C=`Any subprogram`. function::business=`What you do to earn your pay`. function::mathematics=`A total many to one relation between a domain and a codomain`. garbage::=`A piece of storage that has been allocated but can no longer be accessed by a program. If not collected and recycled garbage can cause a memory leak'. generate::=`A hypothetical process that uses a grammar to generate a list of all possible valid statements of sentences in a language`. generic::=`Something that is common accross several species or individuals`. generic::Ada=`A package or Subprogram that can generate a large number of similar yet different packages or subprograms`. See template. global::=`Something that can be used in all parts of program`. Compare with .See local glossary::=`a set of definitions that links terms in a language to an informal description in a natural language, and may also provide examples`. goto::=` a 4 letter word no longer considered correct that is still usable in all practical languages to indicate an unconditional jump`. grammar::=`A formal way of defining syntax`. grammar::math=`A set of definitions that define the syntax of a language. A grammar generates the strings in the language and so implicitly describes how to recognize and parse strings in the language`. .See generate .See parse .See recognise hardware::=`The part of a computer system that is damaged when dropped from a suitable hieght onto a hard floor`. header::C++=`the first part of a function definition that describes how to call the function but does not describe what it does. The header defines the fucntion's signature. A function header can be separated from its function when the body of the function is replaced by a semicolon. This allows $information_hiding and separte development.`. header_file::C++ =`A collection of function headers, class interfaces, constants and definitions that is read by a compiler and changes the interpretation of the rest of the program by (for example) defining operation for handling strings.`. Contrast with $object_file. heap::=`Stirage that can be allocated and deallocated on demand in any pattern`.Compare with $stack. Notice that this heap is not an example of the heap data structure. heap::data_structur=`A clever way of storing a binary tree inside an array that allows efficient insertion and deletion of data into an ordered structure`. hidden::=`result of $hiding`. hiding::=`Process of puting something out of sight, out of mind, and/or out of reach`. .See information_hiding . i,j,k,l identifier::lexeme=`a name used in a programming language to identify something else - a $variable, $function, $procedure, etc.`. identity_operation::=`An operation that returns its arguments unchanged`. identity::mathematics=`An equation that is true for all values of its variables`. .See equation ignorance::=`the comforting result of ignoring something`. implementation::=`the way something is made to work. The grubby details of code and data structures. There are usually many ways to implement something.` implemented::past_participle, `X is implemented by Y` means that an $implementation process has created something called Y that behaves like X. in::=`A way of handling parameters that gives a subprogram access to the value of an actual parameter without permitting the subprogram to change the actual parameter. OFten implemented by $pass_by_value`. infix::=`An operator that is placed between operands. Infix notation dates back to the invention of algebra 3 or 4 hundred years ago`. information_hiding::Parnas=`The doctrine that design choices should be hidden by the modules in which they are implemented` information_hiding::pop=`not being allowed to read the code`. .See encapsulation inheritance::objects=`The abillity to easily construct new data types or classes by extending existing structures, data types, or classes`. inout::=`A way of handling parameters that lets a subprogram both use and change the values of an actual parameter. It can be implemented by $pass_by_reference, pass_by_name, or pass_by_value_result`. input::=`data supplied to some program, subprogram, OS, machine, system, or abstraction`. int::=integer::data_type=`$fixed_point data representing a subset of the whole numbers`. interpreter::program=`A program that translates a single instruction of a prgram and executes it before moving on to the next one`. item::=field::=`A $component in a $compound data $structure`. iteration::=`see $loop`. iterator::=`an object that is responsible for tracking progress through a collection of other objects. Often it is implemented as a reference or pointer plus $methods for navigating the set of objects`. The C++ $STL provides many iterators .See http://www.sgi.com/Technology/STL/Iterators.html $Java has an Enumeration class for iterators: .See http://www.csci.csusb.edu/dick/samples/java.class.tree.html#Enumeration keyword_parameter::=`A parameter with a keyword that indicates the formal parameter to which the actual parameter is to be bound`. late_binding::=`$dynamic_type_binding between pointers to a general type and objects of a more specific type`. lexeme::=`a string of characters in a language that is treated as a single unit in the syntax and semantics. For example identifiers and numbers are often lexemes`. lexical::=`something that is related to the lexemes of a language`. lexicon::=`a set of definitions defining the lexemes in a language`. link::verb=`to connect to things together. In computing: to place addresses in one part of memory so that they identify other parts of memory.` loader::=`nowadays a $link_loader, in the past any program that placed an executable program and placed it into memory.`. linker::=$link_loader. link_editor::IBM=$link_loader. link_loader::=`A program that carries out the last stage of compilatio by $binding together the different uses of identifiers in different files`. local::=`related to the current instruction rather than a larger context`. .See global logical::=`In accordance with the speakers preconceptions`. .See physical. long::C=`A $Fixed_point data type that may have more bits than ints`. loop::=`see $iteration`, for some 99 odd examples of loops in 99 or so languages see .See http://www.ionet.net/~timtroyr/funhouse/beer.html . m,n,o,p,q map::=function::=mapping, maps::noun=`plural of $map`. mapping::mathematics=`A relationship that takes something and turns it into something uniquely determined by the relationship`. mathematical_expression::=`horror, diligence, worry, and (rare) relief`. .Source The Rev'd Charles L. Dodgson, Christchurch, Oxford, UK. Matrix::Mathematics=`An $ADT that can be $implemented by rectangular arrays and has many of the $arithmetic_operations defined on them. A matrix abstracts the structure and behavior of linear $maps`. method::dictionary=`a step by step prescription of a way to achieve some class of goal`. method::methodologist=`a more or less rigorous set of rules that may help solve some set of problems`. method::$OO=`something that an object can perform or suffer often determined by the class of the object rather than the specific object`. In C++ a method is called a member function. methodology::USA=`an expensive and overly complicated method`. methodology::Europe=`The studey of methods`. narrowing::=`a conversion that converts an object to a type that cannot include all the possible values of the object`. natural_numbers::=`The numbers 1,2,3,4..`. object::code=`A piece identifiable storage that can suffer and/or perform various operations`. object::analysis=`Something that is uniqely identifiable by the user`. object::design=`A module that encapsulates a degree of intelligence and know how and has speciallized responsibilities`. .See http://www/dick/samples/objects.glossary.html object_file::=`A piece of compiled code that is $linked into a compiled program after compilation and either during loading or when the program is running.". Do not confuse this use of $object with the later use in programming, analysis and design. operation::=`One of a set of functions with special syntax and semantics that can be used to construct an $expression`. operator::lexeme=`A symbol for an $operation`. Operators can $infix, $prefix, or $postfix. operator_associativity::=`rules that help define the order in which an expression is evaluated when two adjacent infix operators are identical`. operator_precedence::=`rules that help define the order in which an expression is evaluated when two infix operators can be done next`. orthogonal::adjective=`a feature of a language that can be used in all combinations with other features`. .See http://www/dick/cs320/cs320.FAQ.html#What does Orthogonality mean orthogonality::=`property of having $orthogonal features`. out::=`Any mode of passing parameters that permits the subprogram to give a value to an actual parameter without letting the subprogram no what the original value of the subprogram. Only available for general parameters in ada, it can be implemented by $pass_by_result`. output::=`A means whereby data or objects are passed from a part to a wider context` -- for example a program sending data to the operating system so that you can see it on the screen. overloading::=`giving multiple meanings to a symbol depending on its context`. overload::=`to provide multiple context dependent meanings for a symbol in a language`. parameter::mathematics=`A variable constant, or perhaps a constant variable`. parameter::programming=`Something that is used in a subprogram that can be changed when the subprogram is called`. .See formal_parameter .See actual_parameter parameter::TV_pundits=perimeter. .See ignorance paramaters::=plural of $parameter. parameter_passing::=`the means by which the $actual_parameters in a $call of a $subprogram are connected with the $formal_parameters in the definition of the subprogram`. parameter_passing::= $pass_by_value | $pass_by_result | $pass_by_value_result | $pass_by_name | $pass_by_reference. parenthesis::$lexemes="(" | ")". parse::=`To convert a sequence of tokens into a data structures (typically a tree and a name table) that can be used to interpret or translate the sequence'. pass_by_value::=$parameter_passing where `The actual parameter is evaluated (if necessary) and the value placed in a location bound to the formal parameter`. pass_by_result::=$parameter_passing where `A local variable is used as the formal parameter until just before the subprogram returns control at which time the current value is placed into the actual parameter`. pass_by_value_result::=$parameter_passing where `The actual parameter's value is found and is the initial value of the formal parameter. The final value of the formal parameter is returned and replaces the value of the actual parameter as the subprogram returns control`. pass_by_reference::=$parameter_passing where `The parameter is implemented by providing an access path to the actual parameter from the formal parameter. Actions written as if they use or change the formal parameter use or change the actual parameter instead`. pass_by_name::=$parameter_passing where `The expression of the actual parameter is used in place of the formal parameter. Often implemented by a thunk`. pertaining::=`a neat word to put at the start of a definition indicating some kind of loose but intuitive connection`. physical::=`In accordance with the speakers hardware`. .See logical pointer::=data_type with `values that are addresses of other items of data`. polymorphism::objects=`The ability of a function to apply to more than one type of object or data`. polymorphism::=$ad_hoc_polymorphism | $parametric_polymorphism | $late_binding | $dynamic_polymorphism. ad_hoc_polymorphism::=$overloading. parametric_polymorphism::=`A piece of code describes a general form of some code by using a parameter. Different instances or special cases are created by replace these parameters by actual parameters`. Templates in C++, Generics in Ada, and Functors in SML are particular implementations of this idea. positional_parameter::=`A $parameter that is bound by its position`. postfix::$operator=`An operator that is placed after its single operand`. prefix::$operator=`An operator that is placed in front of its single operand`. predicate::Prolog=`A procedure that can fail or succeed to achieve a goal`. Success is finding an instance of a formula that is true and failure means failing to find such an instance. It is assumed that failing to find a solution is proof that the predicate is false. In fact the definition of the predicate may be incomplete or some infinite instance is needed to fit the predicate. predicate::logic=`A formula that may contain variables, that when evaluated should be either true or false`. primitive::=`something that does not need to be defined`. program::English=`a list of things to do`. program::computer=`a set of instructions that a computer is stupid enough to abey, written by a programmer, and often translated by a compiler into a code used by a machine`. protocol::networking=`Rules for sending and receiving data and commands over the network`. protocol::subprogram=`Rules for calling a subprogram` prototype::C=protocol. .See protocol prototype::software_engineering=`A piece of software that requires more work before it is finished, but is complete enough for the value of the finished product to be evaluated or the currant version improved`. quicksort::algorithm=split the data into two roughly equal parts with all the lesser elements in one and the greater ones in the other and then sort each part. -- Prof. C. A. R. Hoare wrote this a young programmer and team leader. His future career started with the publication of this elegant $recursion for placing an array of numbers into order. . r,s,t,u recognize::=`to decide whether or not something belongs in a particular set.` recognizer::math=`an abstract machine or set of rules that defines how to recognize whether a string lies in a given language or not`. record::=record_structure::=$structure.data_type. recurse::=`a step in the process of recursion`. .See recursion recursion::=`A technique of defining something in terms of a smaller or simpler object of the same type. If you don't understand this then see recurse.` .See recurse relation::=relationship. relational::=`pertaining to a relation`. relational_data_base::=`Blessed by Codd and/or cursed by Bachman`. relational_operator::=`an infix operator that returns a Boolean value when given non-Boolean operands`. relational_expression::=`an infix expression in which two non-Boolean values are compared and a Boolean value returned`. scope::=`the parts of a program where a particular identifier has a particular meaning (set of $bindings)`. scoped::=`pertains to languages with particular $scoping rules`. scoping::=`the rules used to determine an identifier's $scope in a language`, see $dynamic_scoping and $static_scoping. selection::=`a statement that chooses between several possible executions paths in a program`. semantics::=`A description of how the meaning of a valid statement or sentence can be worked out from its parsed form`. set::=`a collection of objects, usually of the same type, described either by enumarating the elements or by stating a common property, or by describing rules for constructing items in the set`. stack::=`A collection of data items where new items are added and old items retrieved at the same place, so that the last item added is always the first item retrieved,and so on. An important part of compilers, interpreters, processors and programs`. static::C=`a keyword with too many different meanings pertaining to the life history and scope of varaibles`. static_binding::=`A binding that can be made before a program starts running and can not vary while the program is running`. static_chain::=`a $chain of activation records where each record identifies the block in which it was defined`. statically_scoped::=`something that uses $static_scoping`. static_scoping::=`determining the global $environment of a subprogram as that which surrounds its definition`. structure::data_type=`A finite collection of named items of data of different types`. side_effect::=`A function or expression has a side_effect if executing it changes the values of global variables or its arguments`. structure::program=sequence | selection | iteration | concurrent. subprogram::=`A piece of code that has been named and can be referred to by that name (called) as many times as is needed. Either a procedure or a function`. subprogram_header::=`The part of a subprogram definition that describes how the subprogram can be called without defining how it works`. subtype::=`A type S is a subtype of type T if every valid operation on an object of type T is also a a valid operation of type S`. syntax::=`A description of the rules that determine the validity and parsing of sentences or statements in a language`. .See grammar ternary::=`pertaining to 3. Ternary operators have two operands. Ternary numbers have base 3 and use 3 symbols`. token::=`a particular representation of a lexemes`. tree::=`A collection of connected objects called nodes with all nodes connected indirectly by precisely one path`. An ordered tree has a root and the connections lead from this root to all other nodes. Nodes at the end of the paths are caled leaves. The connections are called branches. All computer science tress are drawn upside-down with the root at the top and the leaves at the bottom. type::=`a collection of similar objects`, See $ADT and $data_type. unary::=`pertaining to one. unary operators have one operand, unary numbers use base 1 and one symbol`. . v,w,x,y,z virtual::C++ = `magic`. Well.... to be more serious. A member function or method is virtual if when applied to a pointer the class of the object pointed at is used rather than the class of the pointer. Virtual inheritance means that when a class in inheritted by two different path only one single parent object is stored for both paths. void_function::C=`a procedure`. void_pointer::C=`A pointer to an object of unknown type and size`. void::Ken_Thompson=`An Abortion`. widening::=`a conversion that places an object in a type that includes all the possible values of the type, and then some`. .Close Glossary of Computer Language Terms