Theory Of Programming Languages

Front 1

design issues for names

Back 1

are names case sensitive? are special words of the language reserved words or keywords?

Front 2

attributes of a variable

Back 2

address, name, value, type, scope, lifetime

Front 3

when is binding done?

Back 3

language design time, language implementation time, compile time, run time

Front 4

static binding

Back 4

variable is bound to memory before run time and is not changed throughout the program

Front 5

dynamic binding

Back 5

variable is bound to memory some time during execution or can be changed during the execution of the program

Front 6

explicit declaration

Back 6

in static type binding, statement in a program that lists variable names and specifies that they are a particular type

Front 7

implicit declaration

Back 7

in static type binding, associates variable with type through default conventions rather than declaration statements (the first appearance of a variable denotes)

Front 8

type inference

Back 8

declaration that is based on context (or use)

Front 9

dynamic type binding

Back 9

variable is bound to a type when it is assigned a value in an assignment statement. variables can change any number of times during execution

Front 10

static variables

Back 10

those that are bound to memory cells before program execution begins and remain bound to those same memory cells until program execution terminates

Front 11

stack-dynamic variables

Back 11

those whose storage bindings are created when their declaration statements are elaborated, but whose types are statically bound. allocated from run time stack

Front 12

advantage of stack-dynamic variables

Back 12

some recursive programs require some form of dynamic local storage

Front 13

disadvantage of stack-dynamic variables

Back 13

run time overhead of allocation and deallocation, subprograms cannot be history sensitive

Front 14

explicit heap-dynamic variables

Back 14

nameless memory cells that are allocated and deallocated by explicit run time instructions written by the programmer. allocated from the heap

Front 15

advantage of heap-dynamic variables

Back 15

can grow or shrink during execution (linked lists and trees)

Front 16

disadvantages of heap-dynamic variables

Back 16

difficulty of using pointers and references correctly, complexity of the required storage management implementation

Front 17

implicit heap-dynamic variables

Back 17

bound to heap storage only when they are assigned values. all attributes of the variable are bound every time they are assigned

Front 18

scope of a variable

Back 18

range of statements in which the variable is visible

Front 19

a variable is visible if

Back 19

it can be referenced in the statement

Front 20

local

Back 20

a variable is this is it declared in the currently active program unit or block

Front 21

static scoping

Back 21

method of binding names to nonlocal variables - can be statically determined before execution

Front 22

blocks

Back 22

section of code that allows new static scopes to be defined in the midst of executable code, typically uses stack dynamic variables

Front 23

problems with static scoping

Back 23

allows more access to variables and subprograms than is necessary

Front 24

dynamic scoping

Back 24

scope is determined at run time because it is based on the calling sequence of the subprograms

Front 25

referencing environment

Back 25

the collection of all variables that are visible in the statement

Front 26

data type

Back 26

a collection of data values and a set of predefined operations on those values

Front 27

descriptor

Back 27

the collection of attributes of a variable

Front 28

primitive data types

Back 28

numeric and character string

Front 29

twos complement

Back 29

take the logical complement and add one

Front 30

precision

Back 30

accuracy of the fractional part of the value, measured in bits

Front 31

range

Back 31

combination of the range of fraction and more importantly, the range of exponents

Front 32

binary coded decimal

Back 32

use binary codes for decimal digits

Front 33

boolean

Back 33

simplest data type: either T/F

Front 34

design issues for character string types

Back 34

should strings be a special kind of character array or a primitive type? should strings have static or dynamic length?

Front 35

static string length

Back 35

string length is static and set when the string is created

Front 36

limited dynamic length

Back 36

string length can be varying up to a declared and fixed maximum set by the variable's definition

Front 37

dynamic string length

Back 37

strings can have a varying length with no max length

Front 38

ordinal type

Back 38

a type in which all the possible values can easily be associated with the set of positive integers

Front 39

enumeration type

Back 39

a type in which all of the possible values, which are named constants, are provided, or enumerated, in the definition

Front 40

enumeration constants

Back 40

defined and groups collections of named constants

Front 41

design issues for enumeration constants

Back 41

is an enumeration constant allowed to appear in more than one type definition, and if so, how is it checked in the program? are enumeration values coerced to integers? are there any other types that are coerced to an enumeration type?

Front 42

overloaded literals

Back 42

when an enumeration literal is allowed to appear in more than one declaration in the referencing environment

Front 43

array

Back 43

a homogeneous aggregate of data elements in which an individual element is identified by its position relative to the first element

Front 44

static array

Back 44

one in which the subscript ranges are statically bound and storage allocation is static

Front 45

fixed stack-dynamic array

Back 45

subscript range is static, storage is dynamic, done at declaration elaboration

Front 46

stack-dynamic array

Back 46

subscript range and storage allocation are dynamic, done at run time

Front 47

fixed heap-dynamic array

Back 47

subscript range and storage fixed at dynamic allocation when requested by user program

Front 48

heap dynamic array

Back 48

subscript range and storage fully dynamic and can change any number of times throughout program execution

Front 49

advantage of static array

Back 49

efficiency: no dynamic allocation/deallocation is required

Front 50

advantage of fixed stack-dynamic array

Back 50

space efficiency because a large array in one subprogram can use the same space as a large array in a different subprogram

Front 51

advantage of stack-dynamic array

Back 51

flexibility because the size of the array does not need to be known until the array is about to be used

Front 52

advantage of fixed heap-dynamic array

Back 52

flexibility because the array's size always fits the problem

Front 53

advantage of heap-dynamic array

Back 53

flexibility because arrays can grow or shrink in size as the need for space changes

Front 54

rectangular array

Back 54

a multidimensional array in which all the rows have the same number of elements and all the columns have the same number of elements

Front 55

jagged array

Back 55

a multidimensional array in which the rows need not be the same length

Front 56

row major order

Back 56

transforms a multidimensional array to a single dimension by mapping the rows first

Front 57

column major order

Back 57

transforms a multidimensional array to a single dimension by mapping thecolumns first

Front 58

record

Back 58

an aggregate of data elements in which the individual elements are identified by names and accessed through offsets from the beginning of the structure

Front 59

fully qualified reference

Back 59

a reference to the record field in which all intermediate record names, from the largest enclosing record to the specific field are named in the reference

Front 60

elliptical reference

Back 60

the field is named, but any or all of the enclosing record names can be omitted so long as the resulting reference is unambiguous in the referencing environment

Front 61

dangling pointer

Back 61

a pointer that contains the address of a heap-dynamic variable that has been deallocated

Front 62

dangling object

Back 62

an object that cannot be referenced or deallocated

Front 63

lost heap-dynamic variable

Back 63

an allocated heap-dynamic variable that is no longer accessible to the user program (also called garbage)

Front 64

tombstone

Back 64

pointer that points to actual data while it is accessible and is changed to null when memory is deallocated

Front 65

lock-and-key

Back 65

pointer and variable must have identical keys in order to reference variable. once memory is deallocated, the variable is given an illegal key

Front 66

reference counters

Back 66

eager approach to garbage collection. once counter is at zero, there are no longer any pointers using the variable and the memory can be deleted

Front 67

mark-sweep

Back 67

lazy approach to garbage collection. collection only occurs when the list of available space becomes empty

Front 68

type checking

Back 68

the activity of ensuring that the operands of an operator are of a compatible type (either legal or can be implicity converted to a compatible type)

Front 69

coercion

Back 69

automatic conversion of an operand in type checking

Front 70

type error

Back 70

application of an operator to an operand of an inappropriate type

Front 71

strong typing

Back 71

a principle that allows no type errors and will check, at run time, for uses of an incorrect type in variables that can store values of more than one type

Front 72

side effect

Back 72

occurs when the function changes either one of its parameters or a global variable (3rd param in a for loop)

Front 73

referential transparency

Back 73

a program has this property if any two expressions in the program that have the same value can be substituted for one another anywhere in the program without affecting the action of that program

Front 74

compound assignment operator

Back 74

shorthand method of specifying a commonly needed form of assignment

Front 75

short-circuit evaluation

Back 75

an expression in which the result is determined without evaluating all of the operands and/or statements