Cs 355 Midterm

Front 1

Program that transforms source code into another target language (usually some low-level machine language).

Back 1

Compiler

Front 2

Represents a memory cell (can appear on left hand side of an assignment statement).

Back 2

Lvalue

Front 3

Database used by a compiler, assembler, linker, and/or run-time system that maps identifier to attributes.

Back 3

Symbol table

Front 4

A generic mechanism for visiting all the objects stored in a container. Frequently used to access objects in C++ standard library containers.

Back 4

Iterator

Front 5

Programming paradigm where objects are collections of data and methods which respectively define the state and behavior of the object.

Back 5

Object Oriented

Front 6

The region of a program where a name is bound to a program entity (e.g. a variable).

Back 6

Scope

Front 7

Technique for exception-safe resource management in C++. Allows the programmer to make some guarantees that allocated resources will be deallocated.

Back 7

Resource Acquisition Is Initialization (RAII)

Front 8

All type errors are detected in this kind of language.

Back 8

Strongly typed

Front 9

A procedure that an object provides as a way to interact with it, possibly accessing its attributes.

Back 9

Method

Front 10

The first entry in a cons cell.

Back 10

car

Front 11

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.

Back 11

Imperative

Front 12

The second entry in a cons cell.

Back 12

cdr

Front 13

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.

Back 13

Lisp

Front 14

Unchangeable.

Back 14

Immutable

Front 15

Class that defines features common to a variety of derived classes but may not be fully defined itself.

Back 15

Baseclass

Front 16

The value of the actual parameter (i.e., a copy) is used to initialize the corresponding formal parameter.

Back 16

Pass by value.

Front 17

High-speed memory cell internal to the CPU.

Back 17

Register

Front 18

Method that can alter the state of an object.

Back 18

Mutator

Front 19

Program that directly executes instructions written in a programming or scripting language, without previously compiling them into a machine language program.

Back 19

Interpreter

Front 20

A category of objects classified according to the members it contains. Defines a new type in an object oriented language.

Back 20

Class

Front 21

An object that is designed to hold other objects.

Back 21

Container

Front 22

A form of self-referencing code that can be easily converted into iteration.

Back 22

Tail recursion

Front 23

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.

Back 23

Closure

Front 24

Method used to assign a cloned value (deep copy) to an object.

Back 24

Copy assignment

Front 25

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

Back 25

Composition

Front 26

Method used to create a new object that is a clone (deep copy) of another.

Back 26

Copy constructor

Front 27

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.

Back 27

Polymorphism

Front 28

Method for releasing resources (e.g., memory) when an object has met its demise.

Back 28

Destructor

Front 29

A type that is solely defined by the operations that you perform on that type.

Back 29

Abstract Data Type (ADT)

Front 30

Smallest syntactical unit that is classified as token by the lexical analyzer.

Back 30

Lexeme

Front 31

Using the same name or operator for multiple purposes.

Back 31

Overload

Front 32

An anonymous function in Common Lisp.

Back 32

Lamda function

Front 33

Programming language paradigm where programs largely consist of a set of reusable subroutines that specify a logical unit of computation.

Back 33

Procedural

Front 34

Fully defined class that can be instantiated.

Back 34

Concrete type.

Front 35

C++ Standard Template Library

Back 35

STL

Front 36

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.

Back 36

Encapsulation

Front 37

This provides the ability to define a new (more specialized) ADT by "borrowing" some or all of the characteristics of another ADT.

Back 37

Inheritance

Front 38

Automatically allocated dynamic variables and subroutine return addresses live here.

Back 38

Stack

Front 39

Only a pointer to the actual parameter is used to initialize a subroutine's formal parameter.

Back 39

Pass by reference.

Front 40

Creation of an object.

Back 40

Instantiation

Front 41

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.

Back 41

Functional

Front 42

Value of a expression (can appear on the right hand side of assignment statement).

Back 42

Rvalue

Front 43

Memory region of a process where variables explicitly allocated by the programmer commonly exist.

Back 43

Heap