314 Final

Front 1

***class file

Back 1

-The JVM translates a class definition into a format a java compiler understands - class file
-Contains JVM instructions, symbol table, and other instructions

Front 2

***JVM is a stack-based

Back 2

stack-based abstract computing machine

Front 3

***ClassLoader

Back 3

Java-supporting web browsers have a subclass of ClassLoader that can load class files over the Internet

Front 4

***JVM allows no byte-level access

Back 4

Direct operations for allocating objects, invoking methods, and accessing fields

Front 5

***bytecodes

Back 5

A class file contains JVM instructions, which are called bytecodes

Front 6

***verification

Back 6

-One of the most distinctive features of the JVM
-ensures that class files loaded in memory follow certain rules and guarantee that programs cannot gain access to field and methods
-cant trick JVM into doing something unsafe

Front 7

***Class area
Java stack
Heap
Native method stacks

Back 7

-code and constants
-"activation records" or "stack frames"
-this is where objects live

Front 8

***<T> void copy(List<T> src, List<? super T> dest)
{ ... dest.add(src.get(i)); ... }
List<Object> lo;
List<String> ls;

Is each of the following true or false

-copy(ls, lo);
-copy(lo,ls);

Back 8

-True
-False

Front 9

***Assume B<T> <: A<T> and Integer <: Number

True (safe) or false (unsafe)

-B<Integer> <: A<Number>
-B<Integer> <: B<Number>
-B<Integer> <: A<Interger>
-For any T, B<T> <: B<?>

Back 9

-False
-False
-True
-True

Front 10

***Suppose that p and q are Haskell parsers. Give an informal explanation of p +++ q

Back 10

If p succeeds it behaves as parser p, otherwise it behaves as parser q

Front 11

***Thread can be in one of the following states:
-new
-runnable
-running
-blocked
-dead

Back 11

-new: just created, not yet started
-runnable: after invoking start() - not scheduled to run yet
-blocked: waiting for a resource, sleeping for some set period of time. When condition met, returns back to runnable state
-dead: after return of run method, cannot be restarted

Front 12

*** What values, evaluate to?
-(\x y -> x == y) "not" "false"

Back 12

-False

Front 13

***What types?
- (1:2:3:[])

Back 13

- Num a => [a]

Front 14

*** What types?
-map (\x -> [x]) "abc

Back 14

-[String]

Front 15

***T/F
-Haskell functions are all total functions

Back 15

-False

Front 16

***T/F
- omit x = 0
keepGoing x = keepGoing(x + 1)
the following code will not terminate (or eventually crash) omit ( keepGoing 5)

Back 16

-False

Front 17

***T/F
-In Haskell, any function with two or more arguments can be used as an infix operator (enclosed in back quotes)

Back 17

-True

Front 18

***T/F
-In Haskell, function application has the highest priority

Back 18

-True

Front 19

***T/F
-Haskell's laziness is what helps guarantee referential transparency

Back 19

-False

Front 20

***T/F
-In a pure functional language, evaluation order affects the value of the computation

Back 20

-False

Front 21

*** What values, evaluate to?
-let filterOut p xs = filter (not . p) xs in filterOut odd [1..5]

Back 21

-[2,4]

Front 22

*** What values, evaluate to?
-((foldr (*) 1) . map (+2) . (filter odd)) [1..4]

Back 22

-15

Front 23

*** What values, evaluate to?
-foldr (++) "" ["Answer", "Is", "Yes"]

Back 23

-"AnswerIsYes"

Front 24

***What types?
-map (\x -> [x])

Back 24

-[a] -> [a]

Front 25

***What types?
-(.) f . g = \x -> f (g x)

Back 25

- (b -> c) -> (a -> b) -> (a -> c)

Front 26

***What types?
-\x y -> x == y

Back 26

-Eq a => a -> a -> Bool

Front 27

***T/F
-In Haskell, a type can be dynamically inferred at run time

Back 27

-False

Front 28

***T/F
-All regular grammars are also context-free

Back 28

-True

Front 29

***
_ Step produces a stream of tokens from a stream of characters

Back 29

-Lexical analysis

Front 30

***
_ Step is essentially undoing abstractions. The result of this step must be executable by some target machine

Back 30

-Code generation

Front 31

***
_ Step transforms the annotated syntax tree into another tree that will result in a more efficient executable code in the end

Back 31

-Optimizing

Front 32

***
_ Step generates a syntax tree from a stream of tokens

Back 32

-Syntactical analysis

Front 33

***
_Step annotates syntax tree with types, checking that types are used correctly

Back 33

-Type checking

Front 34

***
Order:
Code generation, Optimizing, Type checking, Syntactic analysis, Lexical analysis

Back 34

-Lexical, Syntactic, Type checking, Optimizing, Code

Front 35

*** F-bound
<T extends Movable> T translate(T m) { return m.move(1, 1); }

Back 35

interface Movable<T> { T move(int x, int y); }

<T extends Movable<T>> T translate<T>(T m) { return m.move(1, 1); }

Front 36

***F-bound
Assume the following interface:
interface Comparable { bool eq(Comparable); }
<T extends Comparable> bool noteq(T t, T u){ return !t.eq(u); }

Define a class MyInt which is Comparable:

class MyInt extends Comparable {
bool eq(MyInt) { . . . }!// not a valid override
bool eq(Comparable) { . . . } // meaningless comparison
}

Back 36

interface Comparable<T> { bool eq(T); }

<T extends Comparable<T>> bool noteq<T>(T t, T u){ return !t.eq(u); }
class MyInt extends Comparable<MyInt> {
bool eq(MyInt) { . . . }
}

Front 37

Fill in

Back 37

Front 38

***
Explain what a parser is

Back 38

-A parser takes a text (composed of tokens) and determines its syntactic syntax

Front 39

*** What is returned by the following?
failure "parse this"

Back 39

[]

Front 40

** What happens in the monadic parser
p >>= f

if p fails?

Back 40

[]

Front 41

***
Three ways to obtain a Class object

Back 41

-From instance (using Object.getClass()):
MyClass mc = new Myclass();
Class c = mc.getClass();

-From type:
c = boolean.class;

-By name:
Class cls = null;
try{
cls = Class.forName("MyClass");
} catch (ClassNotFoundException e) {
...
}
//use cls