Big, multi-part question that will require you to use one or
more formal techniques to prove properties about a language or program. You will pick up this question 90 minutes before your exam starts.
A general question about language design. To answer it well, you will
need to draw specific examples for programming languages you know.
A specific question about programming paradigms.
A question about anything else covered in the manifest questions.
The questions on the final will be loosely based on manifest questions
selected from this list. The final questions may combine, specialize
or subsume these questions. Not every manifest question appears in
What is a programming language?
What are some design tradeoffs for programming languages?
Why are formal semantics useful?
What is operational semantics?
What do you need for a structured operational semantics?
How to create an operational semantics for a simple language.
How to use an operational semantics to prove properties about a language.
What are the most important programming paradigms?
What are the advantages and disadvantages of functional languages?
What drives the development of new programming languages?
What are the major contributions of Algol60?
What features of a modern programming language (such as Java) are derived from Algol60?
What are Algol's parameter passing mechanisms?
What are the advantages and disadvantages of call-by-name?
You should be able to speak coherently about at least 3
complete rows and 3 complete columns of the language study table we
generate in class today. (See http://www.cs.virginia.edu/~cs655/manifests/languages-summary.html.
You will not be asked specific questions from this, but you should be
able to use concrete examples from these and other language to
illustrate and support you answers.)
What does it mean for a language to have latent or manifest types? What are advantages and disadvantages of each?
What does it mean for a language to have static or dynamic type checking? What are advantages and disadvantages of each?
What does it mean for a language to have weak or strong type checking? What are the advantages and disadvantages of each?
Describe the type system of languages you know.
How to reflect typing rules using operational semantics.
How to create typing rules corresponding to an informal language description.
How to construct a proof that a language fragment is well-typed.
What is data abstraction?
What programming language mechanisms are necessary to support data abstraction?
How to reason about data abstraction implementations using Abstraction Functions and Rep Invariants.
What is rep exposure?
What is object-oriented programming?
What are features of object-oriented programming languages?
What is subtype polymorphism?
What typing judgments belong in object-oriented languages?
What is inheritance?
What does is mean for subtyping to be safe?
When is subtyping safe?
How to show if there is a valid subtype relation between two type specifications using Liskov and Wing's definition of the subtype relation.
What language features enable more elegant designs?
Is multiple inheritance useful?
What are the differences between the typing rules for overriding methods in Eiffel and Java? What are the advantages and disadvantages of each approach?
How can program designers work around inadequate languages?
What are the problems with multiple inheritance?
What solutions have been proposed?
What are the advantages and disadvantages of automated delegation?
What are the comparative advantages and disadvantages of axiomatic semantics, operational semantics and static semantics?
How to use axiomatic semantics to find the weakest pre-condition for some post-condition and code.
What is the difference between partial correctness and total correctness?
How to do a total correctness proof for a simple while loop.
What is Proof-Carrying Code?
Why is checking a proof easier than generating one?
How to use axiomatic semantics to prove type-safety and memory-safety properties.
What is Lambda Calculus?
Is Lambda Calculus a universal programming language?
How to use Beta-reduction to evaluate and understand a Lambda Calculus term.
How to use Lambda Calculus to express simple logic and arithmetic.
What is a fixed point?
How to find the fixed point of a function.
How to understand a recursive definition using a generating function.
How to determine if (D, <=) is a partial order.
What is a bottom in a partial order?
What is a least fixed point?
How to find a fixed point of any lambda term.
What is a functional language?
What is the difference between an eager language and a strict language?
What language features help support functional programming?
What are the advantages of pure functional languages?
What are the disadvantages of pure functional languages?
Why are polymorphic type systems useful?
How does type inference work?
What are the major design flaws of C++?
What was the known about programming language design when C++ was designed?
How do language design flaws effect programmers and users?
What is denotational semantics?
What are the relative advantages and disadvantages of the semantics mechanisms we have seen in this class: operational semantics, static semantics (type judgements), axiomatic semantics, lambda calculus and denotational semantics?
Which of operational semantics, static semantics (type judgements), axiomatic semantics, lambda calculus or denotational semantics is the best tool for a particular problem.
How to define a denotational semantics for a simple programming language.
How to use denotational semantics to prove observational equivalence.
What is type polymorphism?
What is type inference?
How are they related?
How to perform type inference using set constraints and type judgment rules.
What are the limitations of Hindley-Milner type inference?
What is parallelism?
What is a concurrent programming language?
What primitives are necessary to support concurrent programming?
How to understand and define concurrent primitives using a formal semantics.
What are some different abstractions for concurrent programming?
What are the advantages of decoupling parallel processes?
What are tuple spaces?
How to write and understand a Linda-style program.
What are aspects?
What are examples of properties that crosscut programs?
What are the advantages and disadvantages of aspect-oriented programming?
What are the advantages and disadvantages of different memory allocation strategies?
Why do we garbage collect?
How is garbage collection done?
How do language features (for example, pointer arithmetic and weak typing in C) interact with garbage collection?
What is a type qualifier (according to Foster, Fahndrich and Aiken)?
How to understand and develop type rules for type qualifiers.
What are the advantages and disadvantages of non-textual program syntaxes?