CS 6371: Advanced Programming Languages

Course Information

Title: CS 6371: Advanced Programming Languages
Course Registration Number: 3012
Times: TR 4:00-5:15
Location: ECSS 2.312
Instructor: Dr. Kevin Hamlen (hamlen AT utdallas)
Instructor's Office Hours: Thursdays 2:00-4:00, ECSS 3.704
Teaching Assistant: Vishwath Mohan
TA's Office Hours: Wednesdays 3:00-5:00, ECSS 4.610

Final Grades

Final exam grades and final course grades are now posted to eLearning. The "Final Exam" and the "Final Exam Letter" rows record the results of your final exam. The "Final" row at the top is your final course average including both homeworks and exams, and "Final Letter" is your final letter grade for the course.

Letter grade divisions were chosen at fairly wide gaps in the grade distribution, and no students were near the divisions. Thus, it is unlikely that any regrades will affect your final letter grade. However, if you believe there may be a significant grading error, please email me before Wednesday and I will recheck your scores.

Course Summary

This course will cover functional and logic programming, concepts of programming language design, and formal reasoning about programs and programming languages. The following are the course learning objectives:

1. Functional Programming (ML/OCaml)
2. Logic programming
3. Small-step and large-step operational semantics
4. Denotational semantics
5. Fixpoints, fixpoint induction
6. Axiomatic semantics
7. Type theory
8. Untyped and typed lambda calculi
9. Partial evaluation, non-determinism

Through taking this course, students will learn the tradeoffs of imperative vs. non-imperative programming languages, issues involved in designing a programming language, the role of formal semantics and type-systems in reasoning about programs and languages, and proof techniques related to programming language design.

The course is open to Ph.D. students and Masters students. Interested undergraduates should see the instructor for permission to take the course.

Prerequisites: Discrete Structures (CS 3305/5333 or equivalent), Algorithm Analysis and Data Structures (CS 3345/5343 or equivalent), Automata Theory (CS 4384/5349 or equivalent). A solid background in all three of these areas will be heavily assumed throughout the course!

To Prepare for the Course...

The first two lectures of the course are very important so please do not skip them! If you know you will miss them, you should obtain the lecture notes from this webpage once they are posted, obtain the first homework assignment through eLearning, and plan to spend some serious time learning the material on your own.

Although the early course lectures will include a brief survey of the OCaml programming language, students will be expected to learn most of OCaml on their own. Therefore, if you want to get a head start, I recommend downloading and installing OCaml, and walking yourself through some of the many online tutorial examples:

• Download OCaml from the INRIA website. Feel free to use any version you find easiest to get running. If you are comfortable with Unix, I recommend using one of the Unix versions. If you prefer Windows, I recommend the Microsoft-based native Win32 precompiled binary. (Using the Cygwin binaries can be difficult unless you are already familiar with Cygwin and how to configure it.)
• Once you've successfully installed OCaml, try creating a simple program and compiling it. OCaml programs are plain text files, just like C programs. Using your favorite text-editor, create a file named "fib.ml" containing the code found in section 1.9 of the online OCaml manual. At the Unix or DOS prompt, type one of the following to compile the program:
  • On Unix, type: ocamlc -o fib fib.ml
  • At the DOS prompt, type: ocamlc -o fib.exe fib.ml
  (Be sure that the ocamlc.exe binary is in your path and that the fib.ml file you created is in your current directory.) If it compiles successfully, type fib 10 to get it to print the 10th Fibonacci number.
• Start experimenting with the other examples found on page 3 of the OCaml manual. The other examples on that page use OCaml in interactive mode (where you use OCaml sort of like a calculator instead of a compiler). You can either go ahead and use OCaml in interactive mode or incorporate the examples into your .ml file and recompile it to see the results.
• OCaml is an extremely powerful language and has many features that we won't be using in the course. However, in most of the programming assignments you will be free to use any OCaml language features you wish, so the more OCaml you learn, the easier you will find the assignments.

Using OCaml from the UTD Server

If you can't get OCaml to work on your personal machine, you can use OCaml on the UTD CS Department Linux servers. To do so:

• ssh to cscomp.utdallas.edu
• at the Unix prompt, type ocaml to enter interactive mode, or type ocamlc to use the compiler
• to exit interactive mode, at the OCaml prompt type: exit 0;;

OCaml is available on each of the following CS servers: cslinux2.utdallas.edu, cscomp.utdallas.edu, cscomp1.utdallas.edu, cscomp2.utdallas.edu, cscomp3.utdallas.edu. When connecting from off-campus, ssh to cs1.utdallas.edu or cs2.utdallas.edu first, and then ssh to one of the other machines from there.

Using Prolog from the UTD Server

You can install your own local version of SWI Prolog or you can access the version installed on the UTD linux servers as follows:

• ssh to cscomp.utdallas.edu (you must connect through cs1.utdallas.edu if connecting from off campus)
• at the Unix prompt, type pl
• to exit Prolog, type control-C then e

Grading

Homework (40%): Homeworks will be assigned approximately once per 1.5 weeks, and will consist of a mix of programming assignments and written assignments. All programming assignments will be done in OCaml or Prolog. Written assignments will typically involve discrete math proofs. Homeworks must be turned in at the start of class (i.e., by 4:05pm) on the due date. No late homeworks will be accepted.

Midterm (25%): There will be an in-class midterm exam in class on Tuesday, March 2nd. The exam will cover functional programming, operational semantics, denotational semantics, and fixpoints.

Final (35%): The final exam for the course is scheduled for Thursday, May 6th at 2:00pm. The exam will be cumulative, covering all material in the course. Students will have 2 hours and 45 minutes to complete it.

Homework Policy

Students may work individually or together with other students presently enrolled in the class to complete the assignments, but they must CITE ALL COLLABORATORS AND ANY OTHER SOURCES OF MATERIAL that they consulted, even if those sources weren't copied word-for-word. Copying or paraphrasing someone else's work without citing it is plagiarism, and may result in severe penalties such as an immediate failing grade for the course and/or expulsion from the computer science program. Therefore, please cite all sources!

Students may NOT collaborate with students who are not currently enrolled in the class. In particular, it is a violation of the class homework policy to collaborate with a student who took the class in a previous semester or to consult their old homework solutions. These sources are off-limits because such "collaborations" tend to involve simply copying or paraphrasing someone else's answer to a similar homework problem, which does not show that you have learned the material yourself and does not prepare you for the exams.

Texts

The course has no required textbook, but we will make use of several online references:

• OCaml References:
  • The OCaml Manual by Xavier Leroy
  • Developing Applications With Objective Caml by Emmanuel Chailloux, Pascal Manoury, and Bruno Pagano; published by O'Reilly France and now available for online reading
• Operational & Denotational Semantics References:
  • The Formal Semantics of Programming Languages: An Introduction by Glynn Winskel (placed on reserve at the UTD library)
  • Denotational Semantics: A Methodology for Language Development by David Schmidt, out of print but available online
• Logic Programming Resources:
  • Logic, Programming and Prolog (2nd ed.) by Ulf Nilsson and Jan Maluszynski
  • SWI Prolog downloads and manuals

Tentative Course Schedule