[Skip Navigation] [CSUSB] / [CNS] / [CSE] / [R J Botting] / [CSci202] / glossary
[Text Version] [Syllabus] [Schedule] [Glossary] [Resources] [Grading] [Contact] [Question] [Search ]
Notes: [01] [02] [03] [04] [05] [06] [07] [08] [09] [10] [11] [12] [13] [14] [15] [16] [17] [18] [19] [20]
Labs: [01] [02] [03] [04] [05] [06] [07] [08] [09] [10]
Tue May 31 15:31:27 PDT 2011

Contents


    Glossary of Computer Programming 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 specialized term in C++: [ c++.glossary.html ] , object-oriented programming [ objects.glossary.html ] and UML [ uml.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 Modelling Language". [ uml.html ]

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

    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. accessor::=a method or member function that does not change the object to which it is applied, also known as a "const" function..

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

    33. algorithm::=A description in precise but natural language plus mathematical notation of how a problem is solved.

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

    35. argument::English=A heated discussion.
    36. argument::C=parameter. [ parameter ]

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

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

    39. assignment::statement=A statement with an expression and a variable. The expression is evaluated and the result is stored in the variables.

    40. associativity::=rules for determining which of two identical infix operators should be evaluated first.

    41. bind::=to create a binding,
    42. 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.
    43. bindings::=plural of binding.

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

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

    47. bool::C++ =Boolean
    48. 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.

    49. bound::=result of binding.

    50. byte::=eight bits.

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

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

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

    54. 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 ]

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

    56. class::=a description of a collection of objects that have similar structures and behaviors.

    57. code::noun=a piece of text that can not be understood without a key, hence the source code for a program

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

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

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

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

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

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

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

    67. constructor::=a method or function in a class that creates a new object of that class.

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

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

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

    73. default::=An item provided in place of an omitted item.
    74. default_constructor::=`Actions carried out to create an object of a given class when no other data is provided about the object`.

    75. define::=What a definition does.

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

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

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

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

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

      e,f,g,h

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

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

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

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

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

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

    89. float::C=short floating point data type.
    90. 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.

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

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

    93. function::Ada=A subprogram that returns a value but can not change its parameters or have side effects.
    94. function::C=Any subprogram.
    95. function::business=What you do to earn your pay.
    96. function::mathematics=A total many to one relation between a domain and a codomain.

    97. fundamental_data_type::=A type of data that is not defined by a class, struct, or union declaration.

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

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

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

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

    103. 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 ]

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

    105. 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..
    106. 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.

    107. heap::=Storage 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.

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

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

      i,j,k,l

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    127. iteration::=see loop.

    128. 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 ]

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

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

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

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

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

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

      m,n,o,p,q

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

    141. mathematical_expression::=horror, diligence, worry, and (rare) relief.

      Source: The Rev'd Charles L. Dodgson, Christchurch, Oxford, UK.

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

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

    149. mutator::=A method that is permitted to change the state of the object to which it is applied.

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

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

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

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

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

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

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

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

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

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

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

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

    165. parameter::TV_pundits=perimeter. [ ignorance ]
    166. paramaters::=plural of parameter.

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

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

    169. parentheses::="(" | ")". Plural of parenthesis.

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

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

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

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

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

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

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

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

    178. ad_hoc_polymorphism::=overloading.

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

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

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

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

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

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

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

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

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

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

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

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

    193. record::=record_structure::=structure.data_type.

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

    195. 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 ]

    196. relation::=relationship.

    197. relational::=pertaining to a relation.

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

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

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

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

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

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

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

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

    208. static::C=a keyword with too many different meanings pertaining to the life history and scope of varaibles.

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

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

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

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

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

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

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

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

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

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

    219. type::=a collection of similar objects, See ADT and data_type. Objects can be fundamental, pointers, or have theri type determined by their class.

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

      v,w,x,y,z

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

    222. visual::micro-soft=any product that is more expensive than the previous version.

    223. void_function::C=a procedure.
    224. void_pointer::C=A pointer to an object of unknown type and size.
    225. void::Ken_Thompson=An Abortion.

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

    Glossary

  1. accessor::=`A Function that accesses information in an object with out changing the object in any visible way". In C++ this is called a "const function". In the UML it is called a query.
  2. Algorithm::=A precise description of a series of steps to attain a goal, [ Algorithm ] (Wikipedia).
  3. class::="A description of a set of similar objects that have similar data plus the functions needed to manipulate the data".
  4. constructor::="A Function in a class that creates new objects in the class".
  5. Data_Structure::=A small data base.
  6. destructor::=`A Function that is called when an object is destroyed".
  7. Function::programming=A selfcontained and named piece of program that knows how to do something.
  8. Gnu::="Gnu's Not Unix", a long running open source project that supplies a very popular and free C++ compiler.
  9. mutator::="A Function that changes an object".
  10. object::="A little bit of knowledge -- some data and some know how". An object is instance of a class.
  11. objects::=plural of object.
  12. OOP::="Object-Oriented Programming", Current paradigm for programming.
  13. Semantics::=Rules determining the meaning of correct statements in a language.
  14. SP::="Structured Programming", a previous paradigm for programming.
  15. STL::="The standard C++ library of classes and functions" -- also called the "Standard Template Library" because many of the classes and functions will work with any kind of data.
  16. Syntax::=The rules determining the correctness and structure of statements in a language, grammar.
  17. Q::software="A program I wrote to make software easier to develop",
  18. TBA::="To Be Announced", something I should do.
  19. TBD::="To Be Done", something you have to do.
  20. UML::="Unified Modeling Language".
  21. void::C++Keyword="Indicates a function that has no return".

End