CSC 324: Exams

Test Schedule

Final Exam Answers

Sample solutions to the final exam (partial): PDF and PS

Final Examination Details

The final exam will be written at the time set by the Final Exam Timetable. Make sure you note the date, time and room carefully.

The exam is closed-book: no aids are allowed. The exam is set for three hours in length. The questions will not rely on syntax or intimate knowledge of the programming languages we've studied, rather your ability to use what you've learned in the course. The focus will be on the intention of your code and knowing what you can and how you can do it. If you forget the exact name or syntax of a standard or basic programming element, make your intention clear to obtain most or all applicable marks.

The exam will potentially cover anything we've covered in the course. Clearly things we've concentrated on in lecture, tutorial and/or assignments may be tested more thoroughly than topics we've encountered in passing. Programming questions will require basic and important procedures that we've concentrated on in class and on assignments; if they require a specialized procedure, it will be explained sufficiently. The following are some topics that may appear on the exam (don't be startled by the length of this list--most of it is probably second-nature by this point. This list may not be complete, please ask if something seems to be unaccounted for):

• Functional programming
• Scheme programming - short programs/procedures using basic constructs
• Procedures (lambda) and variables (let, define)
• List processing (car/cdr/cons)
• Higher order functions (map, apply, for-each)
• Recursion
• Iteration
• Mutation (set!)
• Syntax extension (macros, define-syntax)
• Continuations (call/cc)
• Logical programming
• Unification
• Prolog programming - short predicate definitions
• Horn clauses
• Rule/fact ordering
• Prolog variables and instantiation
• Accumulators (like reverse/3)
• Prolog search trees
• Prolog lists and structures
• Dynamic facts and rule
• Cut (!)
• Formal grammars (context-free languages/CFGs), BNF, language specification
• Ambiguity in grammars
• Elements of Objects/Object Oriented Programming
• Polymorphism
• Elements of imperative programming
• Generics (templates)
• Pattern matching
• Types / the idea of type inference
• Parameter passing modes
• Scoping
• Static and dynamic properties of programs

There will not be any ML or C++ programming on the exam. I expect you to know the contribution of these languages to the course.

There will be around 8-12 questions. The weight will be shifted slightly to the material since the midterm, but there will be some Scheme questions. Some questions will ask for short programs/procedures/predicates to be written, some will require tracing (and understanding) program behaviour, and others will be concerned with design of programming languages. The questions will be grouped by common topics (i.e., Prolog questions will more-or-less be together), but not sorted in any order of presumed difficulty.

There should be enough space on the exam to fit your answers. If you find you require additional space, there will be extra space on some exam pages. If you find you require lots of additional space, you're probably doing something wrong.

For programming or problem solving, any correct answer will obtain the majority of the marks. Additional marks will be awarded for especially elegant or concise answers, or answers that demonstrate mastery of the programming paradigms.

Midterm Answers

Sample solutions to the midterm: PDF and PS

Midterm Details

The midterm test will be held at 9:10-10:00 on Monday, February 27. The test is closed-book and lasts 50 minutes. The test will be written in the usual lecture room.

The midterm will potentially cover anything up to (but not including) continuations in Scheme (obviously we can't test everything). This includes material covered in lecture, tutorial and the assignment. Particularly, properties of languages, evaluation of languages, concepts of programming languages (scoping, variable binding, etc.) and functional languages (as demonstrated by Scheme). Scheme coverage includes:

• Basic data types, lists, symbols, quoting
• Procedures (lambda) and variables (define, let), closures
• Higher-order functions (apply, map, for-each)
• Mutation (set!)
• Recursion
• Iteration
• Syntax extension (macros, define-syntax)
• Basic pattern matching

For code you are asked to write, the most important thing is the intention of the code. Scheme uses lots of brackets, so if you have one misplaced or missing (as long as the intention is absolutely clear), it will not be penalized.

General information

Check the past course offerings section for links to previous offerings of this course, where you can find term tests and assignments to practice on.

The midterm test will last 50 minutes and will be held during regularly scheduled lecture time.

If you have any serious conflict with the time or date of the midterm test, please inform your instructor immediately to make alternative arrangements.

The midterm test will be closed book (i.e., NO aids allowed), and should be written in pen (remarking requests for tests written in pencil will not be accepted) — the test paper will have lots of room for rough work.

Past Course Offerings

Some previous offerings of this course: Fall 2005, Summer 2005, Winter 2005, Fall 2004
Note: The coverage of this incarnation of the course is somewhat different from other recent offerings, so past exams may bear little resemblance to our course. We are emphasizing different topics, and covering some topics in a different order.