Programming Languages Final
Classify the following languages to their category: Haskell, Lisp, Prolog, C, C++, Perl, Ada, PHP, Python, Smalltalk, Eiffel, Apl, Javascript
C++ Eiffel, Smalltalk - Object oriented Javascript, perl, PHP - Scripting C, Ada - von Neumann prolog - logical Haskell, Lisp, APL - Functional
Explain circumstances under which two mathematically equivalent orderings of the same expression can lead to different results.
C++, use of static member variable side effects code improvement
Some compilers perform all semantic checks and intermediate code generation in action routines. Others use action routines to build a syntax tree and then perform semantic checks and intermediate code generation in separate traversals of the syntax tree. Discuss the tradeoffs between these two strategies
->does not have to construct entire parse tree because attributes of a production are evaluated as they are parsed; they are imbedded in righthand sides of productions ->if the action routine is responsible for much of the semantic analysis, they need contextual information to do their job; an LR parse thus requires access to inherited attributes outside the current production
How can a variable be live but not in scope? Give 2 examples.
1.) Global variable x is still live but not in scope if a local variable x is declared in the scope. 2.) C++: the private member variables of an object of class C are live but not in scope when execution is not inside a member function of C.
Outline the steps carried out by the driver in a shift-reduce parser.
1.) shift tokens from scanner into forest (stack) while keeping track of state until 2.) a right-hand side is recognized and is then 3.) reduced to a left-hand side by popping off the stack and pushing left-hand side back onto right stack contains a record of what parser has already seen, in contrast to top-down parse which keeps track of what it expects to see
What formal rules are needed to define a regular grammar, and how can a regular grammar be extended to a context-free grammar?
3 rules needed: Concatenation, alternation, Kleene closure (repetition) Regular expression to context-free grammar -> add recursion
heap fragmentation
(internal) blocks allocated are more than required resulting in gaps of wasted free memory on heap; (external) alloc blocks scattered through heap causing no room for large allocs despite free space
Difference between context-sensitive and context-free grammars
context-sensitive -> permits expansions based on context of construct like natural language context-free -> relies on potentially recursive rules free of context of the construct
Define and explain the role of: preconditions, invariants, and postconditions.
cover specific checks more succinctly than assertions; structured assertions invariant->true at before and after subroutine call precondition-> true before subroutine postcondition->true after
Explain the difference between a declaration and a definition.
declaration-> introduces name & scope but may omit implementation details definition-> describes object in enough detail for compiler to determine its implementation
What is deep binding and how is it implemented?
deep binding-> choice is made when reference is first created for when object is bound to its referencing environment
What is the primary argument in favor of dynamic scoping?
easy for an interpreter to lookup meaning of name using only a stack of declarations
Describe structured programming.
emphasizes: ->top-down design ->modularization of code ->structured types (records, sets, pointers, multi-dim arrays) ->descriptive names ->lots of comments
epsilon production
empty string on righthand side of a production
What is the handle of an expression, and what is its significance (why is it important)?
handle->left-most simple phrase It is the next node to be processed
What does it mean for a function to be idempotent?
idempotent function->will always return same value when called repeatedly with same arguments
displacement addressing
implicitly providing a predetermined offset to the value in the frame pointer as a part of ordinary load or store instructions
Side effect
influence of subsequent computation in ANY WAY other than by returning a value
LL(n)
left to right scanning; leftmost derivation; n look ahead
LR(n)
left to right scanning; rightmost derivation; n look ahead
nonterminal
left-hand side of production
What language feature prevents top-down parsing? How is this problem resolved (other than switching to bottom-up parsing)?
left-recursion & common prefixes; use disambiguating rule; mechanically remove
Unsafe optimization
may lead to incorrect code
Compile-time constant
named constants whose value is set at compile time by other known constants and built in functions
Explain the difference between subtype polymorphism and parametric polymorphism. Given an example of where each is used. Explain the difference between explicit and implicit parametric polymorphism.
parametric poly->takes type as a parameter; (explicit) generics, statically typed, impl compile time; allows for static type checking; (implicit) an extra type param subtype->code designed to work with subtypes of type T and can be extended (Java); a derived class that does not hide any publicly visible members of its base class is a subtype of that base class
How does a top-down parser proceed through the source code?
parse from the root down; predicts next step to expand current node
Define precedence and associativity, and give examples of common practices for each.
precedence-> certain operators group more tightly than others (ex. multiplication vs. addition; flat precedence in Pascal) associativity->specifies whether operators of equal precedence group left to right or right to left, usually left to right; example 9 - 3 - 2 = 4 NOT 8; Ada's exponentiation operator does not associate
What are some pros and cons of using macro expansion?
pro: cut down on repetitive code via textual substitution; hygienic macros encapsulate their arguments (clojure) cons: naming & binding mechanisms apart from the rest of the language
syntax analysis
process for discovering the syntactic structure of a program
prologue/epilogue
prologue->code executed at beginning of a call as part of stack maintainence epilogue->code executed at the end of the subroutine itself
attribute grammar
provide formal framework/grammar for decoration of a tree
Using pseudocode to simulate near-assembler level code, show the logic flow necessary to implement a counter-controlled loop.
r1 = first r2= step r3=last L1 —loop body r1= r1 + r2 L2 if r1 < r3 goto L1
Using pseudocode to simulate near-assembler level code, show the logic flow necessary to implement an if/then/else block.
r1=A r2=B if r1 <= r2 gotoL4 r1=C r2=D if r1>r2 goto L1 L4 r1= e r2= F if r1 = r2 goto L2 L1 goto L3 //then clause L2 // else clause
What is the role of the semantic analyzer?
role->enforce all static semantic rules and annotate the program with information needed by the intermediate code generator
Describe the behavior and purpose of an iterator.
routine that can enumerate the elements of a collection and may contain yield statements
Describe the phases of the compilation process
scanner -> char stream in; tokens out _ Lexical analysis parser -> tokens in; parse tree out _ Syntax analysis semantic analysis -> parse tree in; _ abstract syntax tree out _ Intermediate code generation Machine-independent code improvement target code generation -> target lang machine specific code improvement
Some languages distinguish between upper and lower-case letters in identifiers (so dog and DOG are distinct in some languages and not others). What are the pros and cons of each?
sensitivity permits code convention & is easier to check insensitivity adds flexibility (SQL) and is forgiving of typos
Name the 8 principal categories of language mechanisms to specify control flow.
sequencing->order statements are executed selection->choice at runtime iteration->repetition procedural abstraction -> subroutines recursion->expression defined in terms of itself concurrency->two or more program fragments executed at once exception handling/speculation->ability to branch to a handler if expected conditions are false nondeterminacy-> ordering/choice unspecified but will lead to correct results
Referencing environment
set of active bindings at a given moment in program execution
token
shortest strings w/ individual meaning
Fibonacci heap
similar to buddy, but sizes grow in fibonacci seq, which is slower than 2^k and results in lower internal fragmenation
keyword/reserved word
specials strings that are in identifier form but reserved for special purpose
What must be done if a nonlocal goto is encountered in a language that supports it?
Kill it with fire
recursive descent parser
LL, expands current node predictively
bottom-up parser
LR; usually hand written; starts from leaves up
Difference between declarative and imperative languages
Declarative- what to do Imperative - How to do
Within the declarative and imperative families, there are several subclasses to classify languages. Name 5 of them
Functional, logic, object oriented, von Neumann, scripting, markup
Do automated tools for finding storage bugs weaken the argument for automatic garbage collection? Justify your answer.
No, tools for finding storage bugs do not guarantee they will be used. Best-practices are ideal but not always practiced. Garbage collection ensures unused memory will be eventually deallocated.
Describe the steps necessary to run Java code
Source code -> Java Compiler -> Java bytecode -> bytecode interpreter OR bytecode -> JIT compiler -> machine language
Using pseudocode to simulate near-assembler level code, show the logic flow necessary to implement a switch statement.
T; &L1 &L2 //array of addresses &L3 L6 r1= (expression) if r1 < 1 goto L5 if r1 > 10 got L5 //L5 is else arm r1 -= 1 //subract off lower bound r1 = T[r1] goto *r1
Describe the difference between leftmost and rightmost derivation. What can we say about these derivations if the grammar is unambiguous?
Rightmost -> replace rightmost nonterminal with righthand side of some production Leftmost -> above except left Grammar is unambiguous if left and right derivations produce the SAME parse tree
Describe the steps necessary to translate C++ source code into a running program. Assume the compiler produces assembly code as an immediate step.
Source code -> preprocessor -> rm w/ space and expand compiler -> produce object code linker ->link object code with libraries output-> program
stack frame
an activation record on the stack for a subroutine containing: args, local vars, temporaries, bookkeeping info
forward reference
an attempt to use a name before its declaration; generally an error
What does it mean for an expression to be referentially transparent?
an expression can safely be replaced by a value because it evaluates to same result regardless of context, a feature of purely functional languages
Describe the difference between applicative and normal-order evaluation
applicative-> evaluate before subroutine call normal-order-> evaluate only when value is needed
conservative v. optimistic compilers
conservative optimization->only applies when optimization is guaranteed safe and efficient optimistic compiler->always uses speculative optimization
frame pointer
a register that points to a known location within the frame of the current subroutine
production
a rule in context-free grammar
How does type coercion reduce the amount of function overloading necessary? What are the main arguments for and against it?
a single function can accept more than a single type by automatic conversion by the compiler it to a type it can use for: improves code reuse and reduces need for explicit casts against: reduces type-errors that can be caught at compile time
S-attributed grammar,
all attributes are synthesized
inheritiance
allows new classes to be defined as extensions or refinements of existing classes
semantic function
arbitrarily complex functions defined by the language designer; example (sum)
Define and explain the role of assertions.
assertions->logical assertions regarding values of program data;
How is precedence of operators established in a grammar, and how does it manifest in the parse tree?
associativity -> grammar groups left to right at same hierarchy precedence -> grammar form hierarchies that group some operations more tightly than others
Describe the difference between best-fit and first-fit heap allocation and the pros and cons of each.
best-fit->search entire list; find smallest block large enough; efficient at reserving large blocks but slow performance first-fit->find first block large enough faster; faster performance but poor space conservation both will split subblock in half if it is significantly smaller than request
Given the code int n = 5; identify 5 different binding times that occur before program execution. (There are more than that, so if you come up with more, that's OK.)
binding times: -language design time -language implementation time -program writing time -compile time -link-time (for separate compilation) -load time -runtime decisions: -static binding before runtime -dynamic binding after runtime
What is short-circuit evaluation? How does it change the semantics of a boolean expression?
boolean evaluation is skipped at the first truth for OR or the first false for AND; code is generated by the compiler to jump out; can be used for null checks or out of bounds checks GOOD: can save time on unnecessary computations; BAD if side effects for full expression are desired
shift-reduce parser
bottom up, w driver described above
Terminal
can be on righthand side; language's tokens
scanner
char stream in, tokens out
Static semantics
check at compile time
Dynamic semantics
check at runtime
Why do compilers produce more efficient code than interpreters?
compilers make decisions earlier than interpreters and can thus take advantage of more optimizations
Describe the difference between static and dynamic links in the context of resolving scopes.
static link->a frame pointer that points to parent frame; keeps track of surrounding scopes dynamic link->reference to the stack frame of the caller
Distinguish between static, stack, and heap objects.
static object -> has absolute address retained throughout program execution stack object->allocated/deallocated in LIFO in conjunction w/ subroutine calls & returns heap object->alloc/dealloc at arbitrary times; a more expensive storage management algorithm is required
Explain the difference between static & dynamic semantics.
static semantic-> compiler enforces rules at compile time dynamic semantic->compiler generates code to enforce dynamic semantics at runtime
buddy system
subblocks are powers of 2; when a block is split, its free pair's address is saved and they are joined back at dealloc if possible
Describe the difference between inherited and synthesized attributes.
synthesized attributes-> attributes whose values are calculated on the lefthand side of a production inherited attributes->attributes whose values is calculated on the righthand side of a production
Why is the code A[index_fn(i)] = A[index_fn(i)] + 1; dangerous in the presence of side effects?
the function used to return an indexing value many contain a side effect and thus may not be the same on both sides
sentential form
the strings of the steps to arrive at derivation
parser
tokens in, parse tree out
predictive parser
top down; table driven; LL; works root down
alieases
two are more names that refer to the same object at the same point in the program; overloaded names
Speculative optimization
usually improves performance but may not
Explain the difference between a value model and reference model of variables.
value model->a named location is set to a value; ex. any int var can contain the value 2 reference model->a named reference to a value—Platonic: only one value
elaboration-time constant
variables that cannot be changed after initialization, persistent
