Use LEFT and RIGHT arrow keys to navigate between flashcards;
Use UP and DOWN arrow keys to flip the card;
H to show hint;
A reads text to speech;
43 Cards in this Set
- Front
- Back
Program that transforms source code into another target language (usually some low-level machine language). |
Compiler |
|
Represents a memory cell (can appear on left hand side of an assignment statement). |
Lvalue |
|
Database used by a compiler, assembler, linker, and/or run-time system that maps identifier to attributes. |
Symbol table |
|
A generic mechanism for visiting all the objects stored in a container. Frequently used to access objects in C++ standard library containers. |
Iterator |
|
Programming paradigm where objects are collections of data and methods which respectively define the state and behavior of the object. |
Object Oriented |
|
The region of a program where a name is bound to a program entity (e.g. a variable). |
Scope |
|
Technique for exception-safe resource management in C++. Allows the programmer to make some guarantees that allocated resources will be deallocated. |
Resource Acquisition Is Initialization (RAII) |
|
All type errors are detected in this kind of language. |
Strongly typed |
|
A procedure that an object provides as a way to interact with it, possibly accessing its attributes. |
Method |
|
The first entry in a cons cell. |
car |
|
Language type that mimics von Neumann architecture where programs are modeled as a sequence of instructions that alter variables that represent memory cells. The assignment statement is central to these type of languages. |
Imperative |
|
The second entry in a cons cell. |
cdr |
|
Family of functional computer programming languages originally developed in 1958 by John McCarthy. All program code is written as s-expressions which are encoded as lists. |
Lisp |
|
Unchangeable. |
Immutable
|
|
Class that defines features common to a variety of derived classes but may not be fully defined itself. |
Baseclass |
|
The value of the actual parameter (i.e., a copy) is used to initialize the corresponding formal parameter. |
Pass by value. |
|
High-speed memory cell internal to the CPU. |
Register |
|
Method that can alter the state of an object. |
Mutator |
|
Program that directly executes instructions written in a programming or scripting language, without previously compiling them into a machine language program. |
Interpreter |
|
A category of objects classified according to the members it contains. Defines a new type in an object oriented language. |
Class |
|
An object that is designed to hold other objects. |
Container |
|
A form of self-referencing code that can be easily converted into iteration. |
Tail recursion |
|
A function that references lexical variables in the environment it is defined within. These lexical variables must remain bound after their containing expression has been evaluated. |
Closure |
|
Method used to assign a cloned value (deep copy) to an object. |
Copy assignment |
|
Creating a data type that contains objects of another type (i.e., defines a "has a" relationship). This is often preferred to inheritance (which defines a "is a" relationship). |
Composition |
|
Method used to create a new object that is a clone (deep copy) of another. |
Copy constructor |
|
The ability to substitute one object for any other object with which it shares an interface (and hence a type). Allows different behaviors to be obtained transparently through a common interface. |
Polymorphism |
|
Method for releasing resources (e.g., memory) when an object has met its demise. |
Destructor |
|
A type that is solely defined by the operations that you perform on that type. |
Abstract Data Type (ADT) |
|
Smallest syntactical unit that is classified as token by the lexical analyzer. |
Lexeme |
|
Using the same name or operator for multiple purposes. |
Overload |
|
An anonymous function in Common Lisp. |
Lamda function |
|
Programming language paradigm where programs largely consist of a set of reusable subroutines that specify a logical unit of computation. |
Procedural |
|
Fully defined class that can be instantiated. |
Concrete type. |
|
C++ Standard Template Library |
STL |
|
Grouping subprograms and data together and providing a mechanism for insulating the interface from the implementation. Implementation details are hidden so objects can be treated more abstractly. When done properly, an object's state may only be modified via its operations. |
Encapsulation |
|
This provides the ability to define a new (more specialized) ADT by "borrowing" some or all of the characteristics of another ADT. |
Inheritance |
|
Automatically allocated dynamic variables and subroutine return addresses live here. |
Stack |
|
Only a pointer to the actual parameter is used to initialize a subroutine's formal parameter. |
Pass by reference. |
|
Creation of an object. |
Instantiation |
|
Language type that focuses on the evaluation of expressions and functions are considered "first class" objects. Computation with side effects are avoided as much as possible. |
Functional |
|
Value of a expression (can appear on the right hand side of assignment statement). |
Rvalue |
|
Memory region of a process where variables explicitly allocated by the programmer commonly exist. |
Heap |