CSci 4651 Programming Languages - Syllabus

[Home] [Syllabus] [Assignments] [Resources]


The syllabus will be updated throughout the semester. Dates, topics, assigned reading, and problem set due dates will be added or might change. All changes in assigned reading and due dates will be announced in class (and occasionally by e-mail). While I will do my best to update the web site accordingly, it is a student's responsibility to keep track of the problem set due dates and reading assignments. If you are not sure about due dates, please don't hesitate to ask.

Reading assignments are listed for the day when the material is first explained in class. You may read the material ahead of the lecture or after, either way is fine.

There will be 5-7 short (15 minutes or so) in-class quizzes throughout the semester on recently covered material. The quizzes will not be announced in advance.

Quizzes, the midterm and the final exams are open book, open notes.

Note that the date for the midterm exam is set and will not change. If you have a conflict with this date, please let me know right away.

All reading is from John Mitchell "Concepts in Programming Languages", unless specified otherwise.

Problem set submission and grading; late problem sets

Problem sets can be submitted on paper or electronically. If a part of your problem set (say, a programming part) is submitted electronically, and a part is submitted on paper, make a note on each saying that this is a part of the submission. Electronic submissions can be sent by e-mail (acceptable formats: plain text, .doc, .pdf, .gz, .tgz, .jar, .jpeg, .gif; if your preferred format is not on this list, please check with me first). Sending a URL of the solution is not acceptable.

It is your responsibility to keep copies of your submitted programs until the problem set is graded, in case there are issues with formats.

Problem sets are due in the beginning of the class on the due date. Late penalty is 25% of the credit if the problem set is sumbitted at or before the next class meeting, 50% if submitted after that. Note that 25% penalty means that 25% of the total credit is subtracted from the score, and then points are subtracted for incorrect solutions (and similarly for 50% penalty).

Each student is allowed to use 2 late coupons throughout the entire semester. Each late coupon waves late penalty for 1 class meeting that the problem set is late. For instance, if a problem set is submitted 2 class meetings late and is accompanied by 2 late coupons, it's graded out of full credit. If it has only one late coupon, it's graded out of 75% credit. To use a late coupon, simply attach to your problem set a sheet with the follwoing information:

Since you only get two late coupons, use them wisely. No other extensions on problem sets will be given, unless exceptional circumstances occur.

Policies on Collaboration and Use of Resources

Problem sets and labs are individual work, unless otherwise stated. While it's perfectly OK (and is encouraged) to discuss the problem sets in general terms with others in the class, your solution must be your own work. Copying any part of another person's solution (even if you modify the code) is considered academic dishonesty and will be dealt with according to the university's policy.

If working in groups, the policy applies to only to collaboration with people not in your group.

Course topics and timeline

Monday Wednesday Friday
Week 1: August 27 - 29
Summer break - no class Introduction, course overview.
Reading: Ch. 1.
A brief history of programming languages. Language classification. Language processing (compilers, interpreters).
Reading: 4.1.1
Week 2: September 2 - 5
Labor day - no class. Computability.
Reading: Ch. 2.
Problem set 1: computability. Due Wedn., Sept. 10
Functional vs. imperative languages, overview of Scheme. Referential transparency.
Reading: Ch. 3, 4.4; Paul Graham's article and Carl de Marcken's notes (see Resources).
Week 3: September 8 - 12
Data representation in Scheme (box-and-pointer model)
Scheme practice (in the lab, second half of the class).
First-class functions in Scheme.
Problem set 1 due.
Problem set 2: Scheme. Due Wedn., Sept. 17.
Discussion of the Paul Graham article.
Introduction to semantics of programming languages, lambda calculus.
Reading: 4.1, 4.2.
Week 4: September 15 - 19
The lambda calculus (continue)
Confluence of the lambda calculus.
Problem set 2 due.
Problem set 3: the lambda calculus. Due Wedn., Sept. 24.
Introduction to denotational semantics.
Reading: 4.3.
Week 5: September 22 - 26
Denotational semantics (continue).
Semantics-based reasoning about programs.
Problem set 3 due.
Problem set 4: denotational semantics. Due Wedn., Oct. 1.
Historic overview of "imperative" languages (Algol, Pascal, C), introduction to ML.
Reading: Ch. 5
Week 6: September 29 - October 3
Introduction to O'Caml (a dialect of ML).
Introduction to ML types, ML assignment statement.
Problem set 4 due.
Problem set 4: ML. Due Wedn., Oct. 8.
More on ML types; ML pattern-matching.
Week 7: October 6 - 10
ML user-defined datatypes.
C and C++ datatypes and memory management.
Reading: TBA
Problem set 4 due.
Problem set 5: ML (cont.), C/C++. Due Wedn., Oct. 15.
Type systems in programming languages. Type checking, type inference.
Reading: Ch. 6
Week 8: October 13 - 17
ML type inference in detail.
Type polymorphism.
Problem set 5 due.
Problem set 6: type inference, type polymorphism. Due Wedn., Oct. 29.
Block-structured languages.
Reading: Ch. 7.
Week 9: October 20 - 24
Fall break, no class Review for the midterm.
Midterm exam. Covers the material up to Friday, October 10.
Week 10: October 27 - 31
Storage management for functions, parameter passing.
Storage management for recursion, higher order functions.
Problem set 6 due.
Problem set 7: Storage management. Due Wedn., Nov. 5.
Storage management (cont.).
Week 11: November 3 - 7
Structured control.
Reading: Ch. 8.1, 8.2 (skipping 8.3, 8.4).
Problem set 7 due.
Problem set 8: Structured control, exceptions. Due Wedn., Nov. 12.
Data abstraction and modularity.
Reading: Ch. 9.
Week 12: November 10 - 14
Modularity. Overview of Modula, Ada.
Object-oriented languages.
Brief historic overview: Simula, Smalltalk, C++, Java.
Reading: Ch. 10.
Problem set 8 due.
Problem set 9: modules; object-oriented languages. Due Wedn., Nov. 19.
Object-oriented languages: Ruby.
Reading: TBA
Week 13: November 17 - 21
Ruby (cont.) C++ and its object-oriented features.
Reading: Ch. 12
Problem set 9 due.
Problem set 10: Ruby, C++. Due Wedn., Nov. 26.
Overview of Java
Object-oriented features in Java
Reading: Ch. 13.
Week 14: November 24 - 28
Java types and subtyping, Java system architecture Parameterized types. Java Generic types
Problem set 10 due.
Problem set 11: Java type system. Due Wedn., Dec. 3
Thanksgiving holiday - no class
Week 15: December 1 - 5
Generic types in C#.
Reading: TBA.
Concurrency, distributed programming.
Reading: Ch. 14 (details TBA).
Problem set 11 due.
Problem set 12: genertic types. Due Wedn., Dec. 10
Distributed systems architectures
Web programming, XML, XML processing (overview).
Week 16: December 8 - 12
Concurrency, threads, Java threads
Java threads
Problem set 12 due.
Last day of classes
Review and wrap up.
Last day to submit any late work.
Final exam: 4-6pm, Monday, Dec 15 in Sci 2185