External Glossary Lookup
In most cases, where terms are introduced or used throughout this reference, they will be linked from the page where they were found to the term on this page. However, terms can be found on this page using the Internal Glossary Lookup found next.
Internal Glossary Lookup
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
Operational note for using this glossary
This is a generalized reference related to programming. Since virtually all the terms are Computer Science terms, they are appropriate for most programming languages. However, one glaring difference is that Java programmers tend to call their subroutines functions, and Java programmers tend to use the more object oriented term methods (which are associated with class components). Since they both mean the same thing operationally, the term functions tends to be used more often in the following definitions since that is used in many more programming languages. However, for purposes of understanding a term, you may assume that the terms function and method are the same thing.
Alphabetical Glossary
abstract (or abstraction) - describing an object or an action in simple terms or with a symbol with limited or no description of the details related to the object or action. For example, many travelers can say that they are "flying to Boston". This is a simple way to tell others what they are doing. However, the actual process of flying to Boston involves packing, driving to the airport, parking one's car, getting a ticket, going through security, and on and on. By stating that they are "flying to Boston", they are representing a fairly complex process with three words but they are leaving out the details; they are abstracting the process
Abstract Data Type (ADT) - a data type that represents a larger or more complicated set of data but does not include all of the details. For example, a DateClass object represents a month, a day, a date, and a year. Rather than talking about all the pieces of data or DateClass operations involved, the programmer can just think of a representative abstraction, such as the DateClass abstraction - the process of using a symbol to represent the more complex thing, and in the process simplify the representation of it
accessModifier - one of a small group of keywords that inform the programmer and the system as to which parts of a program can be accessed by whom. In general, "public" items can be accessed within the class and by any users of the class, "private" items may only be accessed within the class, and "protected" items may be accessed within the class, by subclasses, and by other classes within a given package. The protected modifier is most commonly used to support data/method access for child classes
accessor (or "getter") - a member function in a class that accesses private data for public use without modifying the data
actual parameter (or argument) - the name for a parameter(s) that is used when a function is called from within another function, in other words, when the function is actually used; unlike formal parameters, actual parameters only accept the variables used in the program, without the data type
adjacency (or near neighbor) - in graph theory, an adjacency is a vertex that is directly connected to, or adjacent to, another vertex
algorithm - a standard and/or systematic way to solve a problem or complete a task that includes the step-by-step operations; there are many different kinds of algorithms, but good examples of algorithms are the procedures one must follow to add a list of numbers, or multiply two numbers, or divide one number by another; in each case, one will follow a prescribed process called an algorithm
aliasing - the condition where more than one variable, pointer, or reference points to, or references, the same quantity of data, just as some people might use different aliases or names for the same person (themself). This is helpful in some cases when objects are passed to methods in Java. However, it can become a problem if one of the references makes an unexpected change in the data that causes problems for the other reference
append - for computer data, to add a data item to the end of a data set
applet - a Java program designed to be run inside a web browser, as opposed to being run directly on the computer as is done with Java applications
application - this is a common synonym for a computer program. However, for Java, there are two kinds of programs that can be created. The first is an application, that runs directly on a computer, like most programs, and the second is called an applet, which runs inside a web browser. There are not many differences between applications and applets, but Java programs will only work in the environments for which they are designed. They can be created to work as applets, applications, or both.
array - a group of like things organized together. Arrays in computers are sets of homogenous or like data types that are sequentially stored in a set of cells called elements
array capacity - the number of data items a given array could hold if it were full; this is specified by the constant used to define the array's size when it is first declared
array length (or size) - the number of data items stored in an array to be used in a program. This is not the same as the array capacity which is how many data items it could hold if it were full
array size (or length) - the number of data items stored in an array to be used in a program. This is not the same as the array capacity which is how many data items it could hold if it were full
array bounds (or array boundaries) - when an array is created, it has a fixed amount of memory that is accessible. If a program attempts to assign to, or acquire from, a memory location outside of the allocated array memory, it is said to be accessing/assigning out of bounds
arrow operator - the combination of the dash and greater than operators ("->") used to select a member value when the data has been dynamically allocated and is being managed by a pointer. This is different from the dot operator because a dot operator only works with classes that have been declared within the scope of a function
assignment (or assignment operation) - the act of placing data into a variable in a program, using the assignment operator
assignment operator - the "equals sign" that is used in programming to assign some value on the right side of it to a variable on the left side of it; if there are calculations or functional operations to be implemented on the right side of the operation, they will all be carried out before the assignment operation is implemented
average case - in Big O analysis, it is the circumstance where all the possible iterations of a loop are averaged, or all the possible ways the data can be organized are averaged, or the number of items being manipulated are averaged
base case - the simplest condition that can be solved by a function during a recursive process. If an iterative function has a simple solvable condition, called the base case, then the function can be recalled by itself to recursively solve the remainder of the cases
best case - in Big O analysis, it is the circumstance where a minimum number of operations would be necessary to resolve an algorithm; for a example with iteration, a circumstance where a given loop would iterate some minimum number of times, or not at all for a specified algorithm
Big O Notation - a standardized form for reporting the efficiency of a set of program operations, with emphasis on numbers of items involved and number of repetitive actions required
binary - having to do with two items. Binary processing is conducted on most computers, meaning that the computers use ones and zeroes to conduct their operations
binary file - binary files are sets of data sent to or from storage devices such as hard drives or removable drives. Binary files take up less space than text files, and are commonly used as the storage format for proprietary programs; however, text files are commonly used in educational circumstances since they can be viewed in a text editor to check the results of file I/O operations
bit - the smallest quantity of memory in a computer. Electronically a bit may be on or off but in computer coding operations a bit is either one or zero. The term bit came from compressing the term "binary digit" down into a smaller term
block (or code block) - one or more lines of code that are operated on as an independent group, such as code operated on conditionally in an if statement or a loop; in Java, a code block is commonly identified by being placed between curly braces; in Python, a code block is indented without the use of curly braces
block structure - organizing any code or code segments into groups of text, or blocks, so that the program code is easier to read, understand, modify, or update
branching - literally, changing course in a program; branching is the process of decision making that allows a program to respond differently to various quantities of input or processing; see decision making or selection
breadth first search - in graph theory, this strategy attempts to systematically visit all the vertices that are closest to the original vertex as possible
buffer - a temporary storage area for objects being transferred; keyboard buffers temporary hold numbers or characters until they are accepted by a program
bug - a problem with the program or computer that causes the program to abort inappropriately, or to provide an incorrect or unspecified output. While the word "bug" had been used by programmers before, a story is told about one of the world's first computers. It was very large, with thousands of relays. When the computer experienced difficulties, the technicians tracked the problem to a moth stuck in one of the relays. The moth was tacked to the wall on a poster, and labeled "computer bug"
build (or make) - the process of converting English-oriented programming text into a complete, operational program, commonly called an executable file or program; the build process includes compiling, linking, and usually some level of optimizing
byte - a small group of bits (commonly eight) that make up a data quantity. A byte is considered a standard unit of memory
Bytecode - a set of program commands that have been compiled into a special set of instructions, and prepared for use by the Java Virtual Machine to run as a program on a computer
c-style string - a special application of an array of characters that is always ended with a null character (i.e., '\0'); c-style strings are used when string class objects are, or were, not available
called function or method - the function that conducts the action requested by another function, commonly named the calling function; the calling function puts the called function to work, and when the called function has completed its tasks, the program action is returned to the calling function
calling function or method - the function that implements or uses another function to conduct an action; the function that is presently acting, commonly named the calling function, "calls" another function to get data or processing that it needs; the called function is the function that does the work, and returns the data or results back to the calling function
camel case - the term used for identifiers that seem to have humps in the letters used; examples of camel case identifiers are myProgram, calcFirstRoot, or printAsterisk; the general convention for camel case identifiers is to use a lower case letter to start the identifier and then use upper case letters to identify the beginning of a new word in the identifier
casting (or explicit casting) - temporarily modifying the data type of a variable for a specific operation; casting does not change the variable's data type or have any other effect after the operations; the following is an example of making an integer value appear to be a double value for purposes of a calculation: average = sum / double( numStudents ); see also implicit casting
child, or child node - one data node that is usually associated with trees. Commonly the tree has a "root" node, with two or more "leaf" nodes, which are also called child nodes; when the child nodes have their own leaf nodes, they themselves become root nodes
class - the "blueprint" or definition of what an object will be like, and what it will be able to do when it is instantiated; a class is only deployed in a program to create objects, which are the components that hold and manipulate the data, and implement other appropriate actions
clustering - with consideration for hash tables, this is the condition where many of the data items are grouped adjacently or near each other while other parts of the array are minimally usede
code block (or block) - one or more lines of code that are to be operated on as an independent group, such as code operated on conditionally in an if statement or a loop; in Java, a code block is commonly identified by being placed between curly braces; in Python, a code block is indented without the use of curly braces
code reuse (or reusability) - the characteristic of well-written code modules so that they can be used in other areas of a given program, or possibly in other programs; once a function that prompts for user input and acquires and returns an integer has been written, it can be used in many different environments
coercion (or promotion, or implicit casting) - a process implemented by the compiler to support mathematical operations between two or more different or mixed data types; any time that two or more different data types are used in a mathematical expression, the "lower level" data types will be temporarily changed to the highest data type in the expression only for the duration of the mathematical operations; in Java, for example, a char will be promoted to integer or double; integer will be promoted to double; double will be promoted to long double; and so on
collision - for purposes of data structures such as the hash data structure, this is a situation where one key value that was generated from a given data item is identical to another key value representing another data item. This is usually resolved by having some kind of collision management, such as allowing a linked list to extend the location assigned to that key
combinatorial - a situation where a variety of combined conditions or things might be used to satisfy a given condition or solve some kind of problem; fielding a baseball team is a combinatorial problem in that there needs to be a pitcher, a catcher, and other players and in many cases, there are several players to choose from for each position on the team; the player positions can be combined in many different ways
command prompt - this is the simple text-based display (commonly called the command-line screen, or console window) that waits for a user's command inputs on a single line; programs can be run by typing their names at this prompt, and users can respond to programs by entering data as needed
comment (or program comment) - a text portion of the program that is identified to the compiler as a comment; in Java, two forward slashes ('//') begin a comment that extends only to the end of the present line of text; or to extend comments over multiple lines, the start ('/*') and finish ('*/') indicators are displayed with combinations of an asterisk and a slash as shown; comment text is ignored by the compiler so that the program itself is unaffected by the text; however, the text can assist the reader by explaining the actions of the code
compile - the process of translating a text file containing programming language commands and statements into binary code that can be read and implemented by a computer processor; the compiled file must still be linked to other compiled files to create an executable program
compiler - a software program that implements the compiling process of converting programmer-created source files into processor usable binary code
component - commonly a self-contained module that contributes to the successful operation of a larger system
concatenate, or concatenation - adding string quantities together much like mathematical addition, to result in a string that combines both or all of the string quantities in one string
container - a data management system, being a data structure of its own, that holds other data structures; the other data structures are commonly managed by some form of key or data that can indicate or represent the data in the stored data structures
console I/O - the tools or processes that allow a program to communicate with the console input device, a keyboard, and the console output device, the computer monitor
constant - an identifier used in the program whose value cannot be changed as a variable's value can; constants are very valuable to make clear what certain numbers or quantities exist for in a program; they also allow for much easier maintenance if the constant must be changed at a later time
const reference (or const ref) - a way to pass a parameter so that only the memory address, not the data itself, is passed to the function, giving the function the ability to work with the data, but it is protected from being changed in the function by the const keyword; this provides two solutions: 1) it takes very little time or space overhead to pass one memory address, as opposed to, for example, passing an entire object data set; and 2) the object or other data still acts like a value parameter in the sense that it cannot be changed inside the function, which will keep it from being inappropriately changed elsewhere in the program
constructor - a member function in a struct or class that initializes the object, and prepares it for use
convention - a standardized or commonly accepted practice in a given industry, discipline, or group of professionals. It is a generally accepted convention to put the "Dear Bill" at the beginning of one's E-mails instead of in the middle or at the end; it is not a law, but most people expect to see E-mails written this way. A convention is generally accepted by most folks, whereas a standard may actually be a written rule. Standards and conventions help professionals maintain consistent operations and results in their industries
copy constructor - constructor that is provided initializing data from another object of the same type in order to instantiate the present (or "this") object
copy parameter (or value parameter, or pass by copy) - this is a function parameter-passing operation where a copy of the parameter is passed into the function; any action on the parameter within the function will have no effect on the value in the calling function
current pointer - the current pointer holds the address of the item presently being visited in a linked or other dynamically allocated list
data encapsulation - placing data or other operational components inside a different abstracted quantity which encapsulates or packages the item; creating a struct or a class with data inside is a way to encapsulate data
data hiding - managing data inside a data structure so that only certain functions can actually access the data, and properly manage it, while programmers using the functions have indirect ways to manipulate it; the data can only be modified by the functions that have been tested to correctly work with that data; an example would be a date integer that represents the number of seconds since 1970; programmers using a Date class would never touch this value, but they would be able to interact with the class by setting, accessing, and otherwise modifying months, dates, and years
data stream (or stream) - the metaphorical stream of data flowing from input devices to or through a computer program and/or to or through output devices; all data is assumed to be flowing serially through the computer and accessible by both the computer programs and/or other computer I/O devices
data type - the kind of data to be used in a program. There may be integer, or non-fractional data, floating point, or fractional data, Boolean data, or character data; each of these quantities is a data type; there may also be data types such as classes or structs that are derived from, or developed with, these primitive data types; for example, an extension of an array of characters ended with a null character is called a "c-style" string, and a series of characters can also be managed by a derived quantity called a string class
debug - analyzing a program to find problems that are not allowing the program to meet its operational requirements
debugger - a software product that allows a programmer to step through the source code of a program one statement at a time in order to identify flaws or problems with the program; software companies may vary the capabilities of debuggers, however, in almost all cases, the programmer can at least view the values of various data in the program while it is running so that the proper manipulation of the data, and operation of the program can be verified
decision making - the process of branching, or changing course so that the program can adapt to differing input quantities, processed results, or other conditions; see branching or selection
decrement operator - the "minus-minus" or "--" operator added on to a variable or object to decrement or decrease it by one
default - this is the choice that is made when no other choice is either available or selected; many times, there are standard colors provided for the text and background of a computer program; these color settings are called the defaults. The user may choose to customize her color settings, or she may choose to use the defaults; note that default is also a keyword in Java that is used in switch statements to implement a default response
default constructor - the constructor that is implemented if no other construction or initialization occurs with a given struct or class; in most languages, if a default constructor is not created by the programmer, the compiler will create and use one for the program
delimiter - usually a character that indicates a break between other things; in a data file, data may be divided or delimited by commas, spaces, semicolons, or other characters that are recognized as not being part of the data
depth first search - in graph theory, this strategy attempts to traverse the vertices in such a way as to get as far from the original vertex as possible, as fast as possible
dereference - the action of getting the data "pointed to" from a pointer variable. A pointer variable holds the address of data, but not specifically the data itself; however, if the pointer is dereferenced with the asterisk operator (in the C or C++ programming language), it can provide access to the data
derived data - new data types created by using the language's primitive data types; a Date class or a string class are examples that use various primitive data quantities to generate more complicated data quantities
destructor - a method (function) used in C++ classes that closes out the objects when they go out of scope. For example, if any dynamic data has been acquired, it is commonly released in the destructor operation
dimension - a direction or linear arrangement of something; one dimensional arrays are lists of data; two dimensional arrays are lists of rows of data which also have lists of their own data
DOS - Disk Operating System; this is an older operating system that is not used in most general purpose computer systems; however, most newer operating systems such as MS Windows(TM), allow programmers access to the so called DOS or command-line screen to conduct command-line operations
dot operator - a period after an object variable that tells the compiler that a member quantity, such as data or a method (aka function), is about to follow; example (for a string variable): myString.size(); the member function size is appended after the dot operator, and the combination of the string identifier, the dot operator, and the member function will return the size of the string held by myString
driver - commonly, a function or program that is used to test run or exercise other functions in such a way that the functions' capabilities are tested, or that a program is run
dummy data - data that is used as a place holder, but has no value to the program; sometimes used in stub functions until the appropriate data can be created and processed; also commonly used as data that displays on the screen while the program is running to assist with debugging operations
dynamic memory - this is computer memory that is acquired and/or used during the program operation or runtime; the memory may be acquired, used, and returned to the operating system during any part of the program
dynamic memory allocation - this is the process of requesting and acquiring a segment of memory from the operating system to be used for a specific task; it is commonly used by data quantities that are created during program operation or runtime to respond to the program's needs
edge - in graph theory, the edge is the quantified path between vertices of the graph. A graph is made of both vertices and edges, and the data associated with each paired quantity is managed to model the relationship between them
editor (or text editor) - a simple program that allows one to view, create, modify, or delete text is called an editor; high level word processing programs may be used, but they are usually much more than are needed, and in some cases, they add invisible characters to program code, causing problems later; editors allow one to enter or edit code, save it, and then process it with other programs, such as a compiler
elegant - the condition of simplicity and beauty in an action or deed; good programming that is elegant exhibits quality of solution as well as simplicity and clarity to the program code
element - in Science, it is the name of the smallest chemical component of matter. In Computer Science, an element is one "bucket" in a set of "buckets" that form an array; each element is accessible by having its own unique integer location or offset, called an index
encapsulation - in its most simple form, it means packaging, and in programming, it means packaging data within a class; that data may be hidden or not but it is data that is packaged or encapsulated within the class
endline character - ('\n') the character indicating that the ENTER key has been pressed and/or the end of a line in a text file has been found
enumeration - making some text quantity into a number. Creating constant values to represent flags such as ADD, SUBTRACT, MULTIPLY, and DIVIDE will make the program more readable to humans but allow the computer to use the enumeration number as a referencebeen found
error conditions - any conditions that might cause the program to stop or cause incorrect operations or outputs; well written functions will not allow actions that might cause an unexpected termination of the program but if some failure causes a stack overflow or out of memory error, this cannot be handled in advance by Java' exception management, and will shut down the program
exceptional conditions or Exceptions - any conditions that might cause an inappropriate or unusual action within a function; exceptional conditions may not stop a program's operation, but might cause unexpected or incorrect results
executable (or executable file) - a binary file that contains commands and statements in a form that can be interpreted and implemented by a computer processor; the executable file is the software program that has been created and is run
exhaustive search - the process of searching a set of data from the beginning to the end or at least to the point where the item was found without using any advanced strategies such as divide and conquer; this is considered a brute force strategy
explicit casting (or casting) - temporarily modifying the data type of a variable for a specific operation; casting does not change the variable's data type or have any other effect after the operations; the following is an example of making an integer value appear to be a double value for purposes of a calculation: average = sum / double( numStudents ); see also implicit casting
extensible - the quality of a program that allows it to be easily extended; effective modularity, structure, and readability lead to extensible programs
extraction operator - the C++ operator that allows data to be extracted or acquired from a data stream, which may have come from the keyboard, a disk file, or some other input device; the extraction operator points in the direction the data should flow, which is away from the input object; example: cin >> inputVariable;
file extension - characters added after a file name with a dot or period delimiter. File extensions identify the kind of data held within the file. Spreadsheets might have an extension of .xls (e.g., myspreadsheet.xls), programs might have an extension of .exe (e.g., myprogram.exe), and configuration files that remember things about program set up might have an extension of .cfg (e.g., desktop.cfg). Some operating systems do not require extensions but they still tend to be used in most systems
file I/O - the tools or processes used to send data between a program and a storage device, such as a hard drive, removable drive, etc
file stream - an abstraction for the "stream" of data that flows between hard drives, removable drives, and other storage devices and a program; the file stream is a sub-group of the data stream
flag - a data quantity in a program that becomes set with some data to be communicated or used in some other part of the program; these are usually Boolean quantities but may be integers if more than two flag states are needed; the flags may be set in one part of the program and then used by branching or iterating components later in the program
formal parameter - the name for the parameter(s) in the function header where the function is either implemented at the beginning of a function, or defined in a prototype; unlike actual parameters, formal parameters include data types
free function - a stand-alone function that can be used with any file it is in, or in files that include the file that it is in; free functions, by definition, are not members of classes
function - a segment of code that is created and associated with an identifier so that when the identifier is called, the segment of code will be implemented; functions are a kind of subroutine, which are used to create well structured, modular programs; functions may be simple commands that implement an action (i.e., displayAsterisk), they may be actions that generate new data (i.e., generateRandomNumber), or they may be processors that accept data from the calling function, and manipulate the data to as to provide a desired result (i.e., getSquareRoot); in object-oriented programming, functions are used with associated objects and are called methods
function or method header - the first line of a function (or method) that specifies what the function will return, it specifies the class that the function is a member of when appropriate, it specifies the name of the function (i.e., its identifier), and it specifies the number and data type of parameters to be used by the function
function implementation - the function written with the operating code inside; the implementation of the function is the actual code that will be conducting the operations related to the function; see implementation
function prototype (or prototype) - the declaration to the compiler that a function with this name will be used in some of the following code (i.e., the program). All functions must be prototyped before they can be used in a program
functional abstraction - using functions to represent a specific part of the problem to be solved; the function may not be written or even designed, but its actions are specified by the set of operations it is meant to conduct; functions act as abstractions in that they represent a set of other actions with just one identifier or name
fundamental (or primitive) data type - data types in a programming language that are built in, or are part of the programming language without any modification; primitive data types are also sometimes called fundamental data types
garbage - data that comes from an unknown or inappropriate source. Commonly data that has not been properly initialized will have a garbage value in it
garbage collection - this term refers to the process used in some programming languages such as Java that gives dynamically allocated memory access back to the operating system when it is no longer needed by the program; in other programming languages such as C++, garbage collection must be written into the program, and is commonly implemented as part of the object destruction process
General Protection Fault (GPF) (also called Segmentation Fault) - a program failure that led to an attempt to access data in an inappropriate part of the computer's memory such as another program, or in the operating system; in older operating systems, this would commonly harm or stop the computer operations; in present day computers, it usually just brings up an error message, and shuts down the program
generalizable - the characteristic of an object to be usable under a variety of circumstances; generalizable functions should be adaptable to varying conditions; example: the printAsterisks function can print some variable number of asterisks; this is somewhat generalizable; however a function called printChars can take a character (to be output) and a number of characters to be output, and it can then output any number of any kind of character
generalized case - the generalized case should look like the base case of a recursive process, only slightly smaller; when the base case condition has been resolved, there should be a remaining case that takes care of the rest of the problem, but has been slightly diminished by the solution to the base case condition
generic data - data that is commonly managed in another data structure or container about which the container knows nothing; this data could be related to voters, homeowners, race horse managers, and so on, but the data is all managed in the same way in the container; this also means the container knows nothing about searching or sorting the data but must trust the tools that the data itself provide for the management process
global (or global scope) - program components, such as variables, constants, and functions that have access to all the other parts in the same program code file; it is expected that constants and functions will be used globally, however global variables should never be used
graphical user interface (GUI) - this is the graphical interface that people use with Windows, Linux, or other operating systems; some languages provide the option to use command line operations or GUI operations depending on the program needs; GUI allows much more flexibility with using a mouse, opening and manipulating windows, and entering data into textboxes, or other window-oriented formats
hacking - the process of trying to just sit down and type out code without thinking very much about the problem; This sometimes works with trivial problems, but is rarely effective when the problems become more meaningful, or non-trivial; historically, hacking was not a bad term; some of the first programmers fondly accepted the name hacker; however, now that programmers and software developers have become more scientific and systematic with their work, hacking is no longer needed
hardware - the physical part of a sytem; in computer engineering, hardware is considered to be the computing system while software is the package of instructions that tell the hardware what and how to perform operations
hashing - creating a lookup value from some part of the data; for example, translating the ASCII numbers for the first five letters of a person's name into an array index
head pointer - the head pointer holds the address of the first item in a linked or other dynamically allocated list
header file - a file that supports or provides extra tools for the source code file; in C++, the header file, having the extension .h or .hpp provides tools or references for the source code file, having the extension .cpp; in object-oriented programming, the header file will commonly contain the class declaration information, while an associated source file will contain the operational quantities such as the method implementations; other header files may contain constant values, or other support information
heap memory - an area of memory dedicated to storing program code and non-dynamic, (aka static) data for running programs
helper function - a function that may require a few more parameters or more initial support, while that information is not necessary for the original function call; in many cases, the programmer writes a simple function that takes only the minimum of required parameters, and then has that function call the helper function with all the parameters it might need; this is particularly helpful when writing recursive functions
heuristic - a generalized way to solve a problem; a common heuristic with robot operations is called wall-following; this is a very generalized way of doing things that means that the robot will keep track of either a left or right wall and follow along the wall throughout its movement; the algorithms or actual operational steps for implementing wall-following are significantly more complicated, and can be conducted in a variety of ways
homogenous, or homogeneous - being of generally the same kind of thing; If everyone in the room was 5 feet, 6 inches tall, the people in the room would be considered a homogenous group; in the case of homogenous data, it is data that is all of one data type
I/O - input/output; The abbreviated term I/O is commonly used when referring to any input or output processes with which one is working
IDE - integrated development environment. This is one of several software packages created by different vendors that combines a source code editor, compiler, and a linker so that a programmer can write and create programs without changing between different software products; many IDE's also contain other tools, such as debuggers, optimizers, etc
identifier - a combination of characters and digits that represent various quantities in the program; identifiers may be special Java keywords, or they may be variable names, or they may be function names; in most languages, identifiers must follow a certain set of rules; for example, in Java: 1) identifiers must not start with digits; 2) the number of characters and digits in an identifier may be limited by some compilers; 3) identifiers may not use characters that are reserved for use by the programming language, such as '+', '&', "*', etc; 4) the underscore (i.e., '_') may be used in identifiers, including at the beginnings of those names (e.g., "My_Program", or "_myProgram"); however, it is a good idea not to use the underscore at the beginnings of identifiers because many compilers also do this with identifiers used internally, and unusual or unexpected results may occur which are difficult to diagnose
implementation - the code that actually takes the actions that are associated with a function operation; for example, if a stand alone function has been specified and prototyped at the beginning of a program, its implementation is the function code created later in the document, usually after the main function, or in an associated document; for a member function (in object-oriented programming), it is nearly the same thing; somewhere in the code, a class member function will have been declared or specified; this code is commonly found in a header (*.h) file; somewhere else, usually in a source (*.cpp) file, the function code is written; this is the code that actually does the work of the function (or method); it is called the implementation of the function
implicit casting (or promotion, or coercion) - a process implemented by the compiler to support mathematical operations between two or more different or mixed data types; any time that two or more different data types are used in a mathematical expression, the "lower level" data types will be temporarily changed to the highest data type in the expression only for the duration of the mathematical operations; in Java, for example, a char will be promoted to integer or double; integer will be promoted to double; double will be promoted to long double; and so on
increment operator - the "plus-plus" or "++" operator added on to a variable or object to increment or increase it by one
index - a number indicated a location; with arrays, it is the number identifying a specific element in that array
infinite loop - a loop that continues repeating without end due to a failure to properly control the iteration
infix notation - used when the mathematical operators are located between the operands (i.e., the numbers); example: 5 + 7 - 2
inheritance - in OOP programming, it is the act of extending a given class to a more refined or focused version of the given class. An automobile class might be inherited to a Chevrolet or a Ford, a bicycle class might be inherited to pedal-powered or engine-powered bicycles, and so on
instantiate - the process of creating an object from a class. This is done with a constructor of some kind and a new operator. Note that Java arrays are comparable to objects so they are instantiated as well
initialize - to prepare something for its task; in the case of data, all data must be initialized first as a variable, and sometime later with some value before it is used
initializer list - expressions placed in the header of a constructor that allow the initialization of data to member variables; the initializer list uses the form <member variable>( <new value> ) instead of the assignment operator to initialize the data
inorder traversal - traversal of a binary tree so that the leaves and roots are visited from left to right, meaning left node, root, right node
initialization constructor - a constructor that is given data as part of the construction process so that the object starts out with the data loaded
insert - for program data, this refers to placing data within a certain part of a set of data in order to maintain a certain kind of data arrangement such as sorted order
insertion operator - the C++ operator that allows data to be inserted or placed into a data stream, which may lead to the computer display, a hard drive file, a printer, or some other output device. The insertion operator points in the direction the data should flow, which is toward the output object. Example: cout << "Some Text";
instance variable - a variable defined within a class, which is global to the class and can be accessed by any member method in the class; see also member variable
instantiate or instantiation - to create an object from a class; the class is essentially a blueprint or design as to what the object should look like, and it is in essence the data type; however, when programmers create one or more of the data variables of this kind of class, they are said to instantiate an object of the class; a cookie cutter is much like a class. It has a shape, and every time it is stamped into some cookie dough, a new cookie is instantiated with the same characteristics (i.e., shape) as the cookie cutter; each cookie instantiated by the cookie cutter is considered an object of that cookie cutter type
intuitive - being naturally understandable without requiring other informational support to realize the meaning; e.g., the skull and crossbones icon is said to be an intuitive indicator of danger because most people associate the icon with death
interpreter - some programs, such as C++ programs, are compiled, linked, and executed as stand alone programs; other programs such as some BASIC programs, are interpreted; this means that the computer interprets and acts upon one line at a time; still others, such as Java use a little of both; the Java compiler packages the program into a partially compiled set of commands called Bytecode; the Bytecode does not look like the original source code, but it cannot be run by itself either; the Java Virtual Machine (JVM) interprets the Bytecode steps one at a time, and causes the program to be executed
iteration - repetition of an action, sometimes with refinement or changes to data or program states, sometimes just as a looping process in a program
iterative - a process or condition that is repeated, usually with some kind of refinement or improvement as part of the process; sanding and painting an automobile several times helps create a better quality, and more protective paint job; this is called an iterative process
iterative refinement - the process of developing something from a simple form and repeatedly cycling through the object expanding and/or improving it; programs originally created in a simple way and then continuously expanded and improved are said to be iteratively refined
Java Runtime Environment (JRE) - this is the environment set aside within a computer to run Java programs. It accepts Java ByteCode, converts it into runnable code, and then runs it within the JRE, which is virtual machine running within a computer's operating system
Java Virtual Machine (JVM) - this is a virtual or "pretend" computer that actually works inside other computers or systems to run Java programs; the Java program source code has been compiled to a set of commands in the form of Bytecode, and the JVM translates, or interprets, those commands into a working program
key - some part of a heterogenous data structure that has been arbitrarily chosen to identify and/or represent that data structure. A citizen's data such as name, address, city, state, and so on may use any of the various data but the name is the most likely piece of information used to search for this person's information, so it would commonly be made the key; again however, it could be any of the items depending on the task and the data structure designer
keyword - words or character combinations that are used by the programming language to conduct its affairs; in Java for example, the words int, char, and class are keywords because the programming language needs them to conduct specific operations
kludge - messy, poorly organized, sometimes as result of adding things to a program without an appropriate design; poorly organized or designed programs are considered kludged, or kludgy
leaf node - one of two or more child nodes of another "root" node in a tree environment; it is assumed that leaf nodes do not have their own leaf or child nodes
lexical - having to do with words or letters; string comparisons are conducted lexically first to see if individual letters are equal to, less than, or greater than other letters, according to their position in the alphabet; for example, 'a' is less than 'z' lexically
library function - a function written by someone else for use in normal programs; these functions are common ones such as square root (sqrt), sine (sin), cosine (cos), and tangent (tan) and would be inconvenient to write in a simple program but easy to use when accessed; the location of these most common functions is the cmath library
linear progression (or sequence) - the process of following a given procedure by taking one step, and then the next step in order (or in line), and then the next step, and so on; programs start out operating with linear progression; however, they can be modified to change course or branch away from the linear steps with the use of program branching
linear - having to do with a straight line, or a straight line relationship; linear progression means that the program runs one step to the next and the next and so on; linear program analysis might show that for every ten items, there are ten operations or actions; linear operations will be plotted as a straight line on a graph that compares the number of items to the number of actions in the program
linking - for purposes of program development, the process of combining previously compiled files into one executable file; a program needs several components to run, it needs the ability to accept input and provide output, it needs the ability to communicate with the processor and other hardware in the computer; and so on; the linking process brings together the files that must be added to a new program to allow the program to run on computers with common hardware and operating systems; for purposes of dynamically linked data structures such as linked lists and binary trees, linking is accomplished by storing a copy of a link's address in the node above or ahead of the linked node
linker - the software component that links compiled files
literal - an actual value of something used in the programming code. A literal value may be a number (e.g.,, 74, 4.95, etc), or a string (e.g., bill); in many cases a string value placed in the code is called a string literal
local (or local scope) - the condition of an identifier where it can only be accessed and/or modified in a certain code block (i.e., between an open and closed curly brace set); commonly, local scope refers to the condition that one or more variables have been declared within the scope of a specific function
loop control variable (or lcv)- a variable whose changing state is tested by a working loop to decide whether to continue iterating or not
looping - the controlled process of repeating a given operation or set of operations in order to satisfy a condition of the program specification; see program repetition
magic number - this is the pejorative term for numbers that seem to appear in code. A value of 7.75 makes absolutely no sense until the programmer finds out it is a tax rate, which immediately leads quality programmers to create a constant identifier for the number to make the program more readable. This value can be replaced with STATE_TAX_RATE and have real meaning to any programmer who reviews the code. Then they won't complain about magic numbers . . .
main function (or main method) - this is the function (or method) that actually runs the program. The function calls other functions or methods to create a solution or solve a problem. In most cases, the problem solving code is in another function or method, and in many cases, the other functions or methods may be in another file. For that reason, the main function or method is considered a driver that accomplishes its task by "driving" or calling other functions or methods
maintainable - the condition in which a program is easy to read and understand by any and all programmers who might have a need to debug, modify, or enhance the program at a later time; a program that is not maintainable will not be accepted in professional programming environments
maintenance - either debugging and/or modifying a program to improve or enhance its characteristics
matrix - a templated data structure that can create and manipulate dynamically-sized two-dimensional arrays which are protected from out of range indices; it can also report on its own size as well as implement other data management tasks; since it is a template, it can support creation of classes that can manage any kind of data; this is part of the Standard Template Library (STL)
member function (or method) - a function defined within a class, and associated with an object that can act on the object's own data, or conduct other operations as part of a program
member variable - a variable defined within a class, which is global to the class and can be accessed by any member method in the class; see also instance variable
memory leak - the condition where data is dynamically allocated in a program, but not properly released back to the memory manager; if this occurs very often, the program memory will become tied up, and it will cause program failure, and possible operating system failure
mental model - the overall representation of a problem. A way for the problem solver to "see" what the problem is, and what the steps might be to create a solution for it. All successful problem solvers must be able to create and/or hold a representative "picture" or mental model of the problem in their minds
method (or member function) - a function defined by a class, and associated with an object that can act on the object's own data, or conduct other operations as part of a program
mixed mode mathematics - the implementation of math operations with different data types; for example, an average might be calculated by dividing a double variable containing a sum of scores by an integer variable containing a number of tests
modifier, or mutator - a class member function that implements a change in the class data, usually the private data; the programmer using the class may not directly access or modify the data, but the modifier or mutator functions know how to conduct the proper operations
modular - being a component or small contributing member of a larger package or process; in Computer Science, modularity allows the programmer to build, test, and use small modular components that accomplish unique tasks, and then use them much like building blocks to create larger, more robust programs
modularity - having modular characteristics
monolithic - being of a single component such as a stone or statue; a program is considered monolithic when there is one control point for the whole system that makes all the decisions and takes all the actions; monolithic programming is acceptable until the program becomes large
mutator (or "setter") - a component that can make changes to data within a given object; the data is commonly hidden or inaccessible by the person using the class but the mutator is allowed to modify the private data
nesting - a form of organizing a process so that one process becomes part of another; in the case of branching statements, it is possible to "nest" one set of branching statements inside another group of branching statements; this is true for conditional statements, such as if statements, as well as looping conditions
new operator - used to instantiate an object using a given class constructor. Once the new operator has been implemented, the object declared in the statement will have the abilities found in the class that has been instantiated
node - a segment of data commonly organized to become part of a larger data structure; a linked list node has some data and a reference to the next node; a binary tree node has some data and references to two children nodes; nodes are commonly created and deleted dynamically during program operation
non volatile - the condition of a system where something maintains its capabilities without regard to system power or other management. Hard drives, memory sticks, and other storage devices are capable of storing, modifying, or deleting data but the results of any of these actions will be maintained after the system is powered down. This characteristic is also called persistence
NULL - literally, it means "nothing"; in computer programming, it is a value that indicates that a variable or an object is holding nothing; a NULL pointer is one that is not pointing to anything; operationally, NULL values are usually set to zero for most conditions
null character - ('\0') the character used to indicate the end of a c-style string
object - the data component created in a program that follows the "blueprint" specified by a class; the object may have data that can be modified, displayed, or changed; the object may also have tools called member functions or methods that modify other components, and/or send messages to other objects
object file - a temporary file that is created from one source code file and which will be linked into an executable file when all the object files, and some other supporting files, are linked together to create an executable file
OBOB - "Off By One Bug", usually happens when someone sets up a loop to iterate starting one index too soon or too late, and/or stops the loop one index too soon or too late; in any event, it is a sneaky little critter
OOP, aka Object Oriented Programming - a format for programming where data and operations are created in such a way that they manage themselves, instead of being managed from the outside; objects are not commonly "controlled" by outside functions; instead, other objects send messages to the object to ask it for some part of its data, or to implement a process that the particular object can conduct with its own data or tools; classes are created as the "blueprint" of the objects, and the objects themselves are instantiated, or created, in programs to be used as needed; a simple example of an object managing itself is a string object that can provide its own length; a more complicated example is a date object that "knows" its own day, date, month, and year; if some part of the program changes the date, the date object takes care of making sure that the month, year, and day are still correct for the new date
operator precedence - the rules applied to operators (e.g., '+', '-', '*', etc) in a programming language that decide the order in which operators are applied to a mathematical or logical operation; see order of operations
output - the product of a program or program segment; commonly, output is identified as the screen display that a user sees; however, output can come in other forms such as printed or plotted output, or audio or video output
order of operations - the rules for implementing arithmetic in mathematical expressions; operations are conducted as follows: 1) all operations are conducted from left to right, with the following constraints; 2) expressions within parentheses are conducted first; 2) multiplication, division, and modulo operations are conducted next; 4) addition and subtraction operations are conducted next; 5) the assignment operator is always implemented last, after all other operations have been conducted on the expression
overhead - in computing terms, this represents the resources that are consumed to support a given action or set of actions; a certain action that requires a large amount of memory, or a large amount of processing time, or large quantities of other computer resources is said to require increased or significant overhead
overloaded, or overloading - in Java, it is acceptable to have two or more functions that have the same name, as long as they have different parameters; it is only appropriate to overload functions when they really do the same kind of thing; for example, if a swap function has to be created for integers, characters, doubles, and strings, four different functions could be created with the same name; the functions will implement the same tasks, but will be conducting their operations with different data, and sometimes different operations
parameter - the value or values placed within the parentheses of a function, and therefore passed to and used by that function; the parameter may be a value that needs to be processed, such as when a programmer wants to use a square root function, or it may tell the function how many times to do something, or how many items are to be used, etc; parameters passed to functions will in some way guide the function to accomplish its task
parameter list - the region between the parentheses appended to a function; a function may have one or more parameters of different kinds placed between the parentheses
parse - in Computer Science, it means to separate the smaller parts of data from a larger quantity; if a string is used to bring in a full name, it may be parsed to place the first name, middle initial, and last name into different string variables
pattern - the form of a thing or an action that shows a consistency either in staying the same, or in changing by some measurable amount; once a pattern is found for the thing or the action, it should be possible to predict what presentation or action will occur in the next succeeding steps; in Computer Science, patterns are also generalized programming operations that work for common programming applications
persist - the act of a component to remain active and/or available after a system, or part of a system has terminated. Hard drive data is considered persistent because it remains after the computer has been shut down. Dynamic memory also continues to persist until it is explicitly freed somewhere in a program; until that point, the data persists even if some functions or components have executed and/or terminated
pointer - is a variable that holds a memory address instead of some value that may have been assigned to the memory; pointers support work with dynamic data structures, and allow the ability to pass large amounts of data to functions by just passing the address or pointer, to the data quantity; pointers to strings are also easy to use when passing data to functions; while it is necessary to create dynamic memory space for storing things associated with pointers, the compiler takes care of this job, so it is easy to pass simple strings between functions using a char * pointer
postconditions - the specifications of what the processing a function should implement, and what it should not, as needed; the postconditions specify the state of all the program conditions related to the functions when it has completed its task
postfix notation - used when the operators in a mathematical expression follow the operands (i.e., numbers); also called Reverse Polish Notation (RPN); example: 5 7 +
postorder traversal - traversal of a binary tree in such a way that the leaves are visited first from left to right, and then the root; left child, right child, root
precision- in science, it is the number of significant digits used in mathematical applications, and following a tightly specified set of rules; in computer programming, it commonly means the number of digits to the right of the decimal
precompiler directives - these are program commands that tell the compiler what to do, or sometimes what not to do during the compiling process. For purpose of the program itself, these directives are ignored. They only affect the operation of the compiler
preconditions - the state of all the conditions with which a function might interact when it is called; a function may be given a precondition that the incoming numbers will not be greater than ten nor less than zero, or it might be given the precondition that only lowercase letters will be sent to the function; in any event, when programmers write their functions, they must know the state of all the conditions under which their function might have to work
preorder traversal - traversal of a binary tree in such a way that the roots are visited first, and then the leaves from left to right; root, left child, right child
priming - used mostly for loops, it is the process of acquiring a data item that must be tested to begin or continue the loop or other process; the expectation is that data acquisition will be conducted within the loop operation to continue the process
primitive (or fundamental) data type - data types in a programming language that are built in, or part of the programming language without any modification; primitive data types are also sometimes called fundamental data types
priority queue - a queue that allows priority levels to be used to arbitrarily allow the positioning of some of the data to a location closer to the front of a queue
private - data or functions that may not be used outside of a given class; local class functions can access private data or use private functions, but the private quantities cannot be used by other functions outside of the class program; note that in some languages like Java, private data or functions may be used by other objects of the same class
probing - as pertains to hash tables, probing is one strategy conducted if two data quantities resolve to the same index which is called a collision. Probing means to move past the originally indexed location to a new open location where data can be stored. There are a handful of strategies for probing but the two primary ones are linear probing (i.e., one element at a time) or quadratic probing (i.e., skipping over increasingly larger groups of elements
procedural programming (or imperative programming) - programming using a linear progression strategy where one action is taken, then another action, and so on until a solution has been implemented; procedural programming is presumed to use subroutines such as functions or procedures to conduct parts of the program whereas imperative does not use subroutines
procedure - a function call that may take parameters and takes some action but does not return any processed result to the calling function
promotion (or coercion, or implicit casting) - a process implemented by the compiler to support mathematical operations between two or more different or mixed data types; any time that two or more different data types are used in a mathematical expression, the "lower level" data types will be temporarily changed to the highest data type in the expression only for the duration of the mathematical operations; in Java, for example, a char will be promoted to integer or double; integer will be promoted to double; double will be promoted to long double; and so on
prototype (or function prototype, also called forward declaration) - the declaration to the compiler that a function with this name will be used in some of the following code (i.e., the program). All functions must be prototyped before they can be used in a program
pseudocode - a program, or a program segment, written in English (or the programmer's native language); by writing the program in English, the programmer can think about solving the problem first, and deal with the program syntax later; in addition, a programmer can test the program solution by "running" the program as a set of English instructions first before taking the time to translate it into programming language code
quadratic - a relationship between data that is related to being the number of items squared. If a computer takes 100 operations to process 10 items, and then 10,000 operations to process 100 items, the relationship is considered quadratic
queue - a single or serial line of objects; in Computer Science, a data set that is accessed in a First In, First Out (FIFO) form; data is appended to the "end" of the queue, a process called "enqueueing", and data is reacquired from the "front" of the queue, a process called dequeueing
random access - data that can be accessed usually by some form of addressing, such as in an array; the data can be accessed without searching or traversing through other data components such as lists, or storage files
read priming - this action is commonly required in Java and some other languages since there is no certain test to verify that an item is the last in a file; a program must attempt to acquire a data item, but then it must test for the success of the data acquisition before the program actually uses the data; this "primes" the next action such as storing, displaying, or using the data found in the file; see priming
readability - the characteristic of a program such that anyone familiar with the programming language can easily and quickly read the program along with its comments and know how it works; a well-written program will always be easy to read and understand
record - as pertains to computer programs, it is a package of data abstracted under some name, such as bank account data under the name of a customer, or student information under the name of a college student
recursion - in computer programming, a process where using a function once can resolve a simple problem called a base case; however, when the same problem requires an iterative solution, the function can take care of the one condition, and then call itself to resolve the remaining conditions
reference - in Java, a reference is a variable that can manipulate or use any of the operations of the class it is declared to. Generally speaking, references are used with only one object but the reference can be used for any other objects that have been instantiated from that specified class. If a reference refOne is declared as a class MyClass, it can manipulate any and all other instantiated MyClass objects using the dot operator
reference parameter, or pass by reference - a reference parameter in general is a parameter that accepts data input to a function but is also able to provide output from the function. The output process may vary between languages but the result is the same
repetition - the controlled process of repeating a given operation or set of operations in order to satisfy a condition of the program specification. See looping
reusability (or code reuse) - the characteristic of well-written code modules so that they can be used in other areas of a given program, or possibly in other programs; once a function that prompts for user input and acquires and returns an integer has been written, it can be used in many different environments
robust (or robustness)- being sturdy or difficult to break; being capable of continuing to work properly even when unusual or difficult conditions exist; in Computer Science, it is the job of the programmer to create programs and program components that are robust, and can continue to implement their given task even when unexpected circumstances arise
root node - the parent node of others in a tree oriented environment; root nodes generally have two or more "leaf" nodes, which become root nodes themselves if they have their own child nodes
row major - a convention that considers a two-dimensional array to be a one-dimensional array of other arrays, using the rows as the first location indicator; for example in a theater, it will be much easier to walk to row M before moving across to seat 15, so row major is commonly used in theater seating
scale - the current size or operational level of a system
scaling - the process of adjusting or adapting a smaller system to a much larger operation or state, or in some cases the reverse
scope resolution operator - two adjacent colons placed between a class or struct name, and a member function or member data; the scope resolution operator signifies that the item on the right side of it is a member of the class or struct "family"
scope - the area of code where a data value or function is, or can be, in use; if a constant or variable is defined within a function, it can only be used and "seen" by functions and data in that function, not in other functions; however, if some data is global to a class (e.g., a member variable) it is considered to have class-wide scope and can be "seen" and used by any data or methods within the class
Segmentation Fault (also called Seg Fault, or General Protection Fault) - a program failure that led to an attempt to access data in an inappropriate part of the computer's memory such as another program, or in the operating system; in older operating systems, this would commonly harm or stop the computer operations; in present day computers, it usually just brings up an error message, and shuts down the program
selection - selecting from a variety of potential paths that a program might follow during a program; selection is the process of decision making that allows a program to respond differently to various quantities of input or processing; see branching or selection
self-documenting - the use of appropriately descriptive identifiers for functions, data, or any other program component that explains to the reader what it is that the function does, the data represents, etc (e.g., promptUser, getResponse, calculateDenominator); single-letter variables such as a, b, c, i, j, k, or x, y, or z are rarely ever effectively self-documenting
semantics - the actual meaning of a statement or group of statements; in the case of programming, it is the meaning of a program; in other words, a program should do what it was meant to do; old quote: computer programs do what you told them to do, not what you meant for them to do; semantics is important
sentinel - a character or special number that would not normally be found in a given set of input data, but indicates to the program to make a change; in most cases, when a sentinel value is found in a data set, the program is directed to stop accepting data, end a looping condition, or stop the program; sentinel values may also be returned from some functions if for some reason the function was not able to return an appropriate result
sequence (or sequential) - in Computer Science, organizing, processing, or implementing a specifically defined series of actions, or in some cases managing data in this way; see linear progression
sequential (or serial) access - data that must be accessed in a certain order, such as the order stored on a hard drive, or as added to a linked list
serial, or serially - in Computer Science, the access or treatment of some data quantities in one-at-a-time order as received or as acquired; see sequence
short circuit - when branching statements such as if statements, or while loops are implemented with multiple logical statements, the statements are tested from left to right; if one of the logical statements guarantees failure or success of the branching process, the remainder of the tests will not be implemented; the two conditions are as follows: if the first test (or first few tests) in a branching statement using OR operators evaluates to true, there is no further need to test the remaining logical expressions; on the other hand if the first test (or first few tests) in a branching statement using AND operators evaluates to false, then there is no further need to evaluate the remaining expressions; this allows the program to test for potential problem conditions first before implementing a logical test that is dependent on the quality of supporting data such as indices or pointers
software - used to provide operational instructions to a given computing system which is in turn considered to be the hardware
source code - the simple text file containing the programming language commands and other text components that make up a program; the text file cannot be run as a program; it must be converted by a process that compiles and then links the compiled file with other compiled files to create an executable file (i.e., in Windows(TM), a file ending in .exe); the executable file can then be run as a program
source file - the file containing the source code; the file usually has an extension related to the language in which it was written, such as .cpp for C++ or .java for Java
specifications - a careful description of exactly what the program or program segment is supposed to do; a program, or program segment, should do exactly what it is specified to do - no more, but no less
stack - a group of things placed one on top of the other; in Computer Science, it is a data structure that supports Last In, First out (LIFO); data is "pushed" onto the stack which loads the most recent data item at the beginning of the data set, and "popped" from the stack which removes and commonly returns the most recently loaded item from the beginning of the data set
stack memory - most programs require some working space during their operations; for example, when functions are called, the processor must "set aside" the data in the calling function so that it can go to work on the called function. The data is placed in an operating system controlled data structure called a stack, and then when the called function finishes, the data is taken back off the stack and put back to work in the function; stack memory is considered part of the overhead used by implementing functions
stack overflow - when the stack memory is limited or the program is demanding too much working stack memory, it is the condition where the memory space used by the stack may be depleted or used up, which can lead to program, or even operating system stoppage; this can occur if too much dynamic memory is requested by a program at one time, or the memory leak condition where the program does not return the memory to the operating system when it is no longer needed by the program
standard - a specified rule that is followed by a group of people; a standard may be a written rule that must be followed, or it may be a generally agreed upon rule that is less stringent, such as a convention; standards and conventions help professionals maintain consistent operations and results in their industries
Standard Template Library (STL) - is a standard set of utility classes used by C++ programmers to support frequently required operations; these tools are found in most development systems, and are generally available to everyone; different versions of string and container (data storage and management) classes are available so that programmers do not have to redevelop frequently used operations
statement (or program statement) - any code set that accomplishes at least one programming action, such as assigning a value to a variable, calling a function, or implementing a mathematical process; in Java, each individual statement is terminated by a semicolon although some complex program statements such as the implementation of a function are terminated by the closing curly brace
static - in Java, most methods and variables are associated with the object created around them, and as a result, if several objects are created, then several instances of each method and member variable are also created. However, when a method or variable is identified as static, it means that only one of that method or variable can exist in a give program. This can simplify programming in a single file
stream (or data stream) - the metaphorical stream of data flowing from input devices to or through a computer program and/or to or through output devices; all data is assumed to be flowing serially through the computer and accessible by both the computer programs and/or other computer I/O devices
string (or text) - a short list of characters, such as words, names, or phrases; the name "bill" is a string, as is the address "1234 Anywhere Street"; this may be managed as an array of characters appended with a null character, or it may be manipulated as a string class object
string literal - in a given program, it is an actual string as opposed to a variable; a string object such as myString is a variable quantity; it can hold any number of different strings; however, a string literal stays the same throughout the program. An example of a string literal is: "I like Computer Science"
strongly typed - this is a requirement of many programming languages that the programmer must specify in advance what kind of data a given variable will hold. For example, if a programmer decides that a variable named age will hold a person's age, it will be typed as an integer, and it can never hold any other kind of data after that
structure - a formalized or standard way to organize something; in the case of structured programming, segments of code are placed in certain sections of the program called blocks; structured programming is sometimes also called block structured programming
stub function - this is a function header with open and close curly braces, but no code inside other than a dummy return if the function shows a return data type; stub functions are used to help support a structured design process by delaying the coding of smaller program details
subroutine, or subprogram - a part of a program that acts like its own small program to accomplish tasks required by the larger program; subroutines can be parts of other subroutines, each accomplishing small tasks required by that part of the program; in Java, methods are subroutines: in C or C++, functions are subroutines
syntax - the characters, operators, and punctuation used by a given programming language; the syntax rules not only specify what kinds of characters, operators, and punctuation to use, but they also specify in what order, or under what circumstances they can be used
tail pointer - the tail pointer holds the address of the last item in a linked or other dynamically allocated list
tail recursive - the condition where the actual results of a recursive function occur as it is completing its task, and following any other function calls it has made; tail recursion can be usually be replaced by simple loops (and vice versa)
template - a template is a higher level operation that supports creating a class with the specified data type; once the class is created, an object can be created from there; a template is to a class what a class is to an object; where classes are developed to manage operations with data quantities, templates are created to manage classes with variable data types
templated function - a function that is created with the template keyword so that it can manage any data that is provided to it; a swap function that can swap a variety of data types is commonly developed as a templated function
text editor (or editor) - a simple program that allows one to view, create, modify, or delete text is called an editor; high level word processing programs may be used, but they are usually much more than is needed, and in some cases, they add invisible characters to the code, causing problems later; editors allow one to enter or edit the code, save it, and then process it with other programs, such as a compiler
text file - a storage type of file containing ASCII text characters used for file input or output for some programs; text files are commonly used in the learning environment for ease of file review, but binary files are more commonly used in proprietary programs
top-down - a heuristic that supports providing a solution in a small number of statements, and then expanding on each statement with other sets of statements, which may also use other sets of statements; top-down operations involved abstraction from the top generalized statement to the bottom real action
traverse - the process of "traveling" through a list of data from the beginning of the data set to the end of it, which usually includes some other process, such as sorting them, displaying them, etc
truncate - in Computer Science, to cut off the fractional part of a floating point number; this commonly happens if a double value is assigned to an integer variable; there is no rounding in this process; the fractional part is simply cut off; and this means that 4.01 and 4.99 will both become 4 if they are truncated
type parameter - when using generic data in some programming languages, you will need to tell the generic class what type of data to use; you will pass the data type, instead of the data in method parameters, into the generic class which will then conduct all operations as if the class was designed to work with that particular data type; inside the generic class, a place holder is used during the coding process and again, this placeholder is replaced by the data type when the generic class is being used
unary - having to do with just one parameter or component in an operation. The plus sign ("+") is binary in that it has a number on each side of it; however the plus-plus operator ("++") is unary since it only uses the one value to be incremented
uninitialized variable - this is a variable that is never properly provided a legitimate value with which it can help the program conduct its business; uninitialized variables are said to have garbage values in them
value parameter (or copy parameter, or pass by copy) - this is a function parameter-passing operation where a copy of the parameter is passed into the function; any action on the parameter within the function will have no effect on the value in the calling function
variable - a program identifier that is used to represent data being manipulated by the program; variables can change values anywhere in the program, unlike constants
vector - a templated data structure that can create and manipulate dynamically-sized one-dimensional arrays which are protected from out of range indices; it can also report on its own size as well as implement other data management tasks; since it is a template, it can support creation of classes that can manage any kind of data; this is part of the Standard Template Library (STL)
verbose - literally, "many words"; in some programs, requesting a verbose response will provide a large amount of output or description; programs with verbose settings provide extended information about the program operations which can assist with diagnostics
vertex - in graph theory, the vertex is the quantified end of a path or edge and connected to another vertex. A graph is made of both vertices and edges, and the data associated with each paired quantity is managed to model the relationship between them
void function or method - a function that takes some action in the program, but does not produce a result that can be returned back to the calling function
volatile - the condition of a system where something is active until the power is shut down, at which point it is no longer able to contribute to the system. Volatile memory is memory that works in a computing system until the system is powered down at which time it no longer stores or maintains data
white space - literally, the background space between the areas where code has been written; it is much easier for the eye and the brain to see and understand small segments of code that are separated from each other than it is to figure out code that is all smashed together; note that the background may not be white, but the term white space still means the same thing
widgets - in graphical user interface (GUI) programming, widgets are the radio buttions, check boxes, sliders, and other little devices for entering data into a program. Outside GUI, widgets are small devices or very small programs that can be used within larger systems
worst case - in Big O analysis, it is the circumstance that would require the maximum number of operations possible such as loop that would iterate the maximum number of times possible in a given list or with a given limit value
wrapper class - a class that is developed to emulate a data type that already exists to make the data type available to program operations as objects; this allows object-oriented programs to work with objects instead of fundamental, or primitive data
wrapper function - a function that calls another function that conducts essentially the same actions, but uses different parameters or conditions, and/or is more aligned with the format of the program in which it is used
zero-based - a system that starts at zero; Java arrays are commonly zero based, so that the first element is at index 0, the second element is at index 1, and so on