PROGRAMMING THESAURUS

procedural programming - programming without classes, i.e. using
	   standalone functions, primitive types and simple control
	   structures

standalone function - does not belong to a class

primitive/basic/built-in data types - string, int, bool, char, double

scope - place in program where particular identifier may be used

(variable) shadowing - the outer scope variable becomes invisible when
	   inner scope variable has the same name

synonym (for type) - another name for a type defined by "typedef"

chained/stacked operator - operator that can be used multiple times in
			 a single statement

constant - particular construct (variable) may not change its value
    constant may be initialized at declaration only

lvalue - expression that can be used on the left-hand-side of the assignment

actual parameter - argument (of a function)
formal parameter - parameter

program entry point - main() function

side effect (of a function or expression) - if in addition to
     returning a value, it has an observable action, such as modifying
     state of a variable


function signature/prototype - specifies return value, function name,
	 type and number of parameters

function implementation/body - code for the function

function overloading - multiple different functions within the same
	 scope provided that they have different signatures
function overriding - replacing the function of base class with
	 the function of derived class


resolution (of function call) - compile time process of associating
	   function invocation with function definition

client/caller - function that invokes another function, in design patterns -
	      the code (function) that uses the pattern


unknown things
- undefined: explicitly stated in the standard as not having a
  definitive outcome. Examples include
 
  -- dereferencing a null-pointer
  -- accessing deallocated objects
  -- accessing an array past its boundary

  Oh, and the value of i++ + ++i is undefined

- unspecified: not specified in the standard altogether. Either
  missed, or left up to the implementer (of the compiler). For 
  example, the order of processing of the arguments in a function
  invocation (left or right, right-to-left, or random) is unspecified

- implementation-defined: explicitly specified in the standard as left
  up to the implementer. For example, the return value of sizeof(int).

class attributes(UML term)/fields - member variables
class operators (UML)/methods - member functions
features - member variables and member functions

(class) interface - public class features
(class) implementation - private class features

query accessor member function
modifier - mutator member function

class access modifiers:  prublic, protected, private

inline - request to compiler to replace invocation with implementation

deep copy - memberwise copying of object attributes
shallow copy - recursive (including attributes) copying of entire object

scalar variable - holds a single element
array variable - holds a list of eleents

terse code (style) - short names, compact code
verbose code (style) - longer names, more explanations in code

lazy evaluation/instatation - operation is done as result is needed 
     			      (instantiation is at first use)
eager evaluation/instatiation - operation is done when requested 

opaque implementation - no information/access is provided as to
       		      implementation, ex: maps' memory implementation is
       		      opque

transparent implmementation - information/access is provided to
	     	      implementation, ex: vectors' memory implementation
		      is transparent

techniques of solving recurring tasks

  idiom - low-level language dependent technique

  programming pattern - mid-level, contains: name, problem, solution,
  	    consequences (benefits/side-effects, etc.) language independent

  framework - abstract (high-level), uses several design patterns,
  	     leaves users (programmers) to provide code to specify behavior

inheritance notation

  superclass - base class, generalization of the derived class, parent class
  subclass - derived class, specialization of the base class, child class

early (compile-time) binding - resolving function by compiler
late (run-time) binding - resolving function by program itself on the
     		basis of object class pointed-to

abstract function (method/operation) - defines only signature but not implementation
    realized in C++ using pure virtual functions
concrete function - function with provided implementation

abstract class - a class with at least one abstact function
abstact interface - all public functions are abstract

downcasting - changing pointer (or reference) type to base classes
	      (moving down the inheritance tree)

upcasting - changing pointer (or reference) type to derived classes
	    (moving up the inheratiance tree)

factory - object for creating other objects 

covariant return type - return type of the overriding function that
	  	 is a subclass (of the basic class), in general
		 covariant proceeds down the inheritance hierarchy

template instantiation - compiler substituting actual type for
	 template type parameter and generating executable code on the
	 basis of template

template deduction - determining by the compiler the type prameter
	 based on argument type, context
template specialization - alternative template implementation
	 of templates (or methods) for specific types


callback - reference to code (function) to be used in another function
	 ex: function pointers, functors, lambda expressions
lambda expression - nameless function often used inline as a callback
       parameter in another function
functor (function object) - an object that overloads function call operator
	and may be used as callback
binder (function adapter) - a specialized function that creates a function
       by assigning (binding) a particular parameter of another function
       to a value