[Skip Navigation] [CSUSB] / [CNS] / [Comp Sci Dept] / [R J Botting] / [Samples] / glossary
[Index] [Contents] [Source Text] [About] [Notation] [Copyright] [Comment/Contact] [Search ]
Fri Sep 28 16:05:29 PDT 2007


    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: [ Ref in info4 ]

      For acronyms and abbreviations, please see ikind@mcimail.com's [ babel95b.html ]

      For methods: [ methods.html ]

      For particular languages: [ ada.glossary.html ] [ c++.glossary.html ] [ comp.html.glossary.html ] [ Glossary in java ] [ objects.glossary.html ] [ prolog.glossary.html ] and [ smalltalk.glossary.html ]

      A Thru Z

    1. Ada::=Programming language dedigned for programming embedded applications.
    2. Ada::=Ada83 | Ada95. [ ada.glossary.html ]

    3. ADT::=Abstract data type.
    4. ADT::=data_type with hidden implementation details.
    5. ADT::abreviation="Abstract Data Type".

    6. ASCII::=The original common character code for computers using 8 bits. [ comp.text.ASCII.html ]

    7. BASIC::="Beginners All-purpose Symbolic Insctruction Code", a family of languages developed for teaching programming and given away with early IBM PCs.

    8. BNF::=Backus Naur Form. An old version of a popular way to define syntax of programming languages. Also see EBNF and XBNF.

    9. 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. [ BOOLEAN_ALGEBRA in math_41_Two_Operators ]

    10. C::=`Programming Lnaguage invented to help develop operating systems.
    11. C::= "K&R C" | ANSI_C. [ c.glossary.html ]
    12. C++::=Hibrid child of C with object oriented features and generic fuunctions and classes.
    13. C++::=BJarne Stroustroup's C++ | ANSI/ISO_C++. [ c++.glossary.html ]

    14. CLOS::="Common LISP Object System`, a modern LISP.

    15. COBOL::=COmmon Business Oriented Language.

    16. EBNF::=Extended BNF. A popular way to define syntax as a dictionary of terms defined by using iteration, options, alternatives, etc. [ BNF ].

    17. 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.

    18. HTML::=HyperText Markup Language. -- used to define pages on the WWW.
    19. HTML::=HTML_1 | HTML_2 | HTML_3 | ... . [ comp.html.glossary.html ]

    20. Java::=Object oriented language that has a C-like syntax.
    21. Java::=a language for consumer boxes | Java_0 | Java_1.0 | ... [ Glossary in java ]

    22. LISP::=LISt Processing language, The key versions are LISP1.5, CLOS, and Scheme. [ lisp.html ]

    23. PL::=Programming Language.

    24. Prolog::=PROgramable LOGic. [ prolog.glossary.html ]

    25. Scheme::=a modern statically scoped version of LISP.

    26. UML::="Unified Modeling Language". [ uml.html ]

    27. UNICODE::=a new 16 bit International code for characters. Used in Java. [ http://www.unicode.org/ ] [ principles.html ]

    28. 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

    29. abstract::mathematical=algebras and logics that describe several different concrete algebras and logics.

    30. abstract::software_engineering=descriptions that do not swamp you with unnecessary detail -- they provide enough information to use something without knowing its detailed construction.

    31. active::=A piece of code is active if the CPU is currently executing instructions in the code. Contrast with suspended.

    32. actual_parameter::=Any parameter in the call of a subprogram.

    33. algebra::=A shorthand for calculations that can be used to solve some problems.

    34. algorithm::=A description in precise but natural and mathematical language of how a problem is solved.

    35. alias::=Two names or identifiers are aliases if they name or identify the same thing.

    36. argument::English=A heated discussion.
    37. argument::logic=A set of premises connected by correct deductive steps to one or more conclusions.
    38. argument::C=parameter. [ parameter ]

    39. arithmetic_operations::=addition, subtraction, multiplication and division ideally forming an ADT with the algebraic properties of a ring or field. [Hoare69]

    40. array::data_type=Each array associates each value of one data type with a unique object of another type

    41. 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.

    42. associative::math=Algebra with S:Sets & +:infix(S,S,S) & For all a,b,c:S( (a+b)+c = a+(b+c) ).

    43. associativity::=rules for determining which of two infix operators with the same priority should be evaluated first. For instance adding 1 to 2 to give 3 and then adding 3 to get 6, gives the same result as adding 1 to the result of adding 2 and 3.

    44. bind::=to create a binding,
    45. 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.
    46. bindings::=plural of binding.

    47. binary::=pertaining to 2. Binary operators have two operands. Binary numbers have base 2 and use 2 symbols.
    48. bit::=binary digit. A unit of information introduced by Shannon in the 1940's.

    49. block::program_structure=A piece of source code that has one or more declarations in it.

    50. bool::C++=Boolean
    51. 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.

    52. bound::=result of binding.

    53. 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.

    54. byte::=eight bits.

    55. 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.

    56. call::=to make use of something by writing its name and the correct protocol.

    57. call_by(X)::=oldfashioned way of saying: pass_by(X).

    58. case_esac::=a pair of delimeters in Algol 68 and the UNIX Bourne Shell indicating the start and end of a set of cases. In the Bourne and Born-Again Shell each case has this syntax
    59. regular_expression ")" #commands ";;" [ unix.commands.html ]

      In Algol 68 (I think) it was

    60. sequence "in" sequence#("," sequence)

      In languages based on C the case-esac structure became a 'switch' statement with each case looking like

    61. "case" int_constant ":" # statement "break;" (roughly).

    62. 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.. [ ccc.html ]

    63. chain::data_structure=any kind of linked_list, a set of records where each record identifies the next record in some sequence or other.

    64. class::=a description of a collection of objects that have similar states and behaviors.

    65. code::noun=a piece of text that can be understood without a key, hence any program

    66. coercion::=an implicit type conversion that lets a smart compiler work out the wrong meaning for a programmers typing mistake.

    67. compile::verb=translate source code into executable object code.
    68. compiler::= lexer ->- parser ->- generator ->- optimizer ->- linker.

    69. component::syntactic=a part of a compound statement or object,
    70. 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.

    71. compound::=a single statement or object that can have any number of other statements as its parts.

    72. conditional::=an expression or statement that selects one out of a number of alternative subexpressions.

    73. 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).

    74. control_statement::=statements that permit a processor to select the next of several possible computations according to various conditions.

    75. coroutine::=a named piece of code that can be restarted by another coroutine and vice versa. The simplest form of psudo-concurrency.

    76. 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.
    77. data_type::=structure | enumerated | primitive | array | file | pointer | ... .
    78. data_type::formal=Net{ Values::Set, Operations::@(%Values->Values), Assumptions::Finite_set(well_formed_formula) }.

    79. declaration::= variable_declaration | constant_declaration | type_declaration | subprogram_declaration | ... .

    80. 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.

    81. default::=An item provided in place of an omitted item.

    82. define::=What a definition does.

    83. 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.

    84. delimiter::=A symbol or character that indicates where something else begins or ends.

    85. descriptor::=A place that stores the properties of variables when a program is compiled or interpretted.
    86. dictionary::=Any set of definitions.

    87. do::=`a delimeter used in FORTRAN and nearly every succeeding language as part of a loop construct.

    88. do-od::=a pair of delimeters in Algol 68 indicating the start and end of a loop.

    89. do-done::=a pair of delimeters in the Bourne Shells indicating the start and end of a loop.

    90. dynamic::=something that is done as the program runs rather than by the compiler before the program runs.

    91. dynamic_binding::=A binding that can be made at any time as a program runs and may change as the program runs.

    92. dynamic_chain::=a chain of activation records where each record identifies the activation in which it was called.

    93. dynamically_scoped::=something that uses dynamic_scoping.
    94. dynamic_scoping::=determining the global environment of a subprogram as that which surrounds its call.

    95. 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.


    96. encapsulated::programming=coding that can be changed with out breaking client code.
    97. 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.

    98. 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).

    99. enumerated::data_type=data defined by listing its possible values.

    100. 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.

    101. eof::abbreviation="End of File", used in several languages, in different syntaxes to detect when no more data can be read in from a file.

    102. 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.

    103. erroneous::Ada=A program whose result depends on the particular implementation used, rather than the meaning of the language.

    104. esac::lexeme, see [ case-esac ] for details.

    105. exception::=a mechanism for handling abnormal situations.

    106. expression::=A shorthand description of a calculation. [ mathematical_expression ]

    107. expression::=part_of_a_program with value:data.

    108. expression_of_type(T)::=expression with value:values(T).

    109. 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.

    110. 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.

    111. formal::=something that is abstract or mathematical | formal_parameter | a process that has more or less well defined rules.

    112. formal_parameter::=The symbol used inside a subprogram in place of the actual_parameter provided when the subprogram is called. [ call ]

    113. 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.
    114. function::Ada=A subprogram that returns a value but can not change its parameters or have side effects.
    115. function::C=Any subprogram.
    116. function::business=What you do to earn your pay.
    117. function::mathematics=A total many to one relation between a domain and a codomain.

    118. 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'.

    119. generate::=A hypothetical process that uses a grammar to generate a list of all possible valid statements of sentences in a language.

    120. generation::verb= The process of creating some new things from some old things.
    121. generation::noun= The set of things that resulted from creating some new stuff from something old. Traditionally hardware went through a series of generations: (tubes, transistors, integrated circuits, large scale integrated circuits). People have attempted to set up a similar set for software, in the hopes of being able to market new software tools and methoids as "the next generation". Similarly for languages. 4th generation languages for example, are an attempt to incomporate more intelligent behavior into interpretters and compilers without having a good understanding of what makes intelligence first -- but I am biased here!

    122. generic::=Something that is common accross several species or individuals.
    123. generic::Ada=A package or Subprogram that can generate a large number of similar yet different packages or subprograms. See template.

    124. global::=Something that can be used in all parts of program. Compare with [ local ]

    125. glossary::=a set of definitions that links terms in a language to an informal description in a natural language, and may also provide examples.

    126. goto::= a 4 letter word no longer considered correct that is still usable in all practical languages to indicate an unconditional jump.

    127. grammar::=A formal way of defining syntax.

    128. 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. [ generate ] [ parse ] [ recognise ]

    129. hardware::=The part of a computer system that is damaged when dropped from a suitable hieght onto a hard floor.

    130. 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..
    131. 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.

    132. 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.

    133. 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`.

    134. hidden::=result of hiding.
    135. hiding::=Process of puting something out of sight, out of mind, and/or out of reach. [ information_hiding ]


    136. identifier::lexeme=`a name used in a programming language to identify something else - a variable, function, procedure, etc.`.

    137. identity_operation::=An operation that returns its arguments unchanged.
    138. identity::mathematics=An equation that is true for all values of its variables. [ equation ]

    139. ignorance::=the comforting result of ignoring something.

    140. implementation::=the way something is made to work. The grubby details of code and data structures. There are usually many ways to implement something.
    141. implemented::past_participle, X is implemented by Y means that an implementation process has created something called Y that behaves like X.

    142. 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.

    143. infix::=An operator that is placed between operands. Infix notation dates back to the invention of algebra 3 or 4 hundred years ago.

    144. information_hiding::Parnas=The doctrine that design choices should be hidden by the modules in which they are implemented

    145. information_hiding::pop=not being allowed to read the code. [ encapsulation ]

    146. inheritance::objects=The abillity to easily construct new data types or classes by extending existing structures, data types, or classes.

    147. 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.

    148. input::=data supplied to some program, subprogram, OS, machine, system, or abstraction.

    149. int::=integer::data_type=fixed_point data representing a subset of the whole numbers.

    150. interpreter::program=A program that translates a single instruction of a prgram and executes it before moving on to the next one.

    151. item::=field::=A component in a compound data structure.

    152. iteration::=see loop.

    153. 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 [ Iterators.html ] Java has an Enumeration class for iterators: [ Enumeration in java.class.tree ]

    154. keyword_parameter::=A parameter with a keyword that indicates the formal parameter to which the actual parameter is to be bound.

    155. 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.

    156. lexical::=something that is related to the lexemes of a language.

    157. lexicon::=a set of definitions defining the lexemes in a language.

    158. 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.

    159. loader::=nowadays a link_loader, in the past any program that placed an executable program and placed it into memory..
    160. linker::=link_loader.
    161. link_editor::IBM=link_loader.
    162. link_loader::=`A program that carries out the last stage of compilatio by binding together the different uses of identifiers in different files`.

    163. local::=related to the current instruction rather than a larger context. [ global ]

    164. logical::=In accordance with the speakers preconceptions. [ physical] .

    165. long::C=A Fixed_point data type that may have more bits than ints.

    166. loop::=see iteration, for some 99 odd examples of loops in 99 or so languages see [ beer.html ]


    167. map::=function::=mapping,
    168. maps::noun=plural of map.
    169. mapping::mathematics=A relationship that takes something and turns it into something uniquely determined by the relationship.

    170. mathematical_expression::=horror, diligence, worry, and (rare) relief. The Rev'd Charles L. Dodgson, Christchurch, Oxford, UK.

    171. 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.

    172. method::dictionary=a step by step prescription of a way to achieve some class of goal.
    173. method::methodologist=a more or less rigorous set of rules that may help solve some set of problems.
    174. 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.
    175. methodology::USA=an expensive and overly complicated method.
    176. methodology::Europe=The studey of methods.
    177. narrowing::=a conversion that converts an object to a type that cannot include all the possible values of the object.

    178. natural_numbers::=The numbers 1,2,3,4...

    179. object::code=A piece identifiable storage that can suffer and/or perform various operations.
    180. object::analysis=Something that is uniqely identifiable by the user.
    181. object::design=A module that encapsulates a degree of intelligence and know how and has speciallized responsibilities. [ objects.glossary.html ]

    182. 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.

    183. operation::=One of a set of functions with special syntax and semantics that can be used to construct an expression.
    184. operator::lexeme=A symbol for an operation. Operators can infix, prefix, or postfix.

    185. operator_associativity::=rules that help define the order in which an expression is evaluated when two adjacent infix operators are identical.

    186. operator_precedence::=rules that help define the order in which an expression is evaluated when two infix operators can be done next.

    187. orthogonal::adjective=a feature of a language that can be used in all combinations with other features. [ What does Orthogonality mean in cs320.FAQ ]
    188. orthogonality::=property of having orthogonal features.

    189. 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.

    190. 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.

    191. overloading::=giving multiple meanings to a symbol depending on its context.

    192. overload::=to provide multiple context dependent meanings for a symbol in a language.

    193. parameter::mathematics=A variable constant, or perhaps a constant variable.

    194. parameter::programming=Something that is used in a subprogram that can be changed when the subprogram is called. [ formal_parameter ] [ actual_parameter ]

    195. parameter::TV_pundits=perimeter. [ ignorance ]
    196. paramaters::=plural of parameter.

    197. 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.

    198. parameter_passing::= pass_by_value | pass_by_result | pass_by_value_result | pass_by_name | pass_by_reference.

    199. parenthesis::lexemes="(" | ")".

    200. 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'.

    201. 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.

    202. 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.

    203. 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.

    204. 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.

    205. 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.

    206. pertaining::=a neat word to put at the start of a definition indicating some kind of loose but intuitive connection.

    207. physical::=In accordance with the speakers hardware. [ logical ]

    208. pointer::=data_type with values that are addresses of other items of data.

    209. polymorphism::objects=The ability of a function to apply to more than one type of object or data.

    210. polymorphism::=ad_hoc_polymorphism | parametric_polymorphism | dynamic_type_binding | dynamic_polymorphism.

    211. ad_hoc_polymorphism::=overloading.

    212. 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.

    213. positional_parameter::=A parameter that is bound by its position.

    214. postfix::operator=An operator that is placed after its single operand.

    215. prefix::operator=An operator that is placed in front of its single operand.

    216. 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.

    217. predicate::logic=A formula that may contain variables, that when evaluated should be either true or false.

    218. primitive::=something that does not need to be defined.

    219. program::English=a list of things to do.
    220. 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.
    221. protocol::networking=Rules for sending and receiving data and commands over the network.

    222. protocol::subprogram=Rules for calling a subprogram

    223. prototype::C=protocol. [ protocol ]

    224. 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.

    225. 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.


    226. recognize::=to decide whether or not something belongs in a particular set.

    227. recognizer::math=an abstract machine or set of rules that defines how to recognize whether a string lies in a given language or not.

    228. record::=record_structure::=structure.data_type.

    229. recurse::=a step in the process of recursion. [ recursion ]

    230. 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. [ recurse ]

    231. refactor::=Improve code by a series of simple steps under conditions when the working code remains working.

    232. relation::=relationship.

    233. relational::=pertaining to a relation.

    234. relational_data_base::=Blessed by Codd and/or cursed by Bachman.

    235. relational_operator::=an infix operator that returns a Boolean value when given non-Boolean operands.

    236. relational_expression::=an infix expression in which two non-Boolean values are compared and a Boolean value returned.

    237. scalar::datatypes=any data type that is not a vector, array, or structure. A value that can not be broken down into sensible pieces. Examples in C++: bool, int, char, float, double, long, enum{....}, wchar. In Pascal: char, integer, real, subranges, ...

    238. scope::=the parts of a program where a particular identifier has a particular meaning (set of bindings).
    239. scoped::=pertains to languages with particular scoping rules.
    240. scoping::=the rules used to determine an identifier's scope in a language, see dynamic_scoping and static_scoping.

    241. selection::=a statement that chooses between several possible executions paths in a program.

    242. semantics::=A description of how the meaning of a valid statement or sentence can be worked out from its parsed form.

    243. 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.

    244. smop::="Simple (or Small) Matter of Programming", pronounced "S M O P",
      1. A piece of code, not yet written, whose anticipated length is significantly greater than its complexity. Used to refer to a program that could obviously be written, but is not worth the trouble. Also used ironically to imply that a difficult problem can be easily solved because a program can be written to do it; the irony is that it is very clear that writing such a program will be a great deal of work. "It's easy to enhance a Fortran compiler to compile COBOL as well; it's just an SMOP."
      2. Often used ironically by the intended victim when a suggestion for a program is made which seems easy to the suggester, but is obviously (to the victim) a lot of work.

    245. 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.

    246. static::C=a keyword with too many different meanings pertaining to the life history and scope of varaibles.
    247. static_binding::=A binding that can be made before a program starts running and can not vary while the program is running.
    248. static_chain::=a chain of activation records where each record identifies the block in which it was defined.

    249. statically_scoped::=something that uses static_scoping.
    250. static_scoping::=determining the global environment of a subprogram as that which surrounds its definition.

    251. structure::data_type=A finite collection of named items of data of different types.

    252. side_effect::=A function or expression has a side_effect if executing it changes the values of global variables or its arguments.

    253. structure::program=sequence | selection | iteration | concurrent.

    254. 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.

    255. subprogram_header::=The part of a subprogram definition that describes how the subprogram can be called without defining how it works.

    256. 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.

    257. syntax::=A description of the rules that determine the validity and parsing of sentences or statements in a language. [ grammar ]

    258. ternary::=pertaining to 3. Ternary operators have two operands. Ternary numbers have base 3 and use 3 symbols.

    259. token::=a particular representation of a lexemes.

    260. 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.

    261. type::=a collection of similar objects, See ADT and data_type.

    262. unary::=pertaining to one. unary operators have one operand, unary numbers use base 1 and one symbol.

    263. Unicode::=UNICODE.


    264. 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.

    265. void_function::C=a procedure.
    266. void_pointer::C=A pointer to an object of unknown type and size.
    267. void::Ken_Thompson=An Abortion.

    268. widening::=a conversion that places an object in a type that includes all the possible values of the type, and then some.

    . . . . . . . . . ( end of section Glossary of Computer Language Terms) <<Contents | End>>