CS 6371: Advanced Programming Languages

Course Information

Title: CS 6371: Advanced Programming Languages
Course Registration Number: 24620/003641
Times: TR 1:00–2:15
Location: FO 1.202
Instructor: Dr. Kevin Hamlen (hamlen AT utdallas)
Instructor's Office Hours: TR 2:30–3:30 (ECSS 3.704)
Teaching Assistant: Shreya Soman
TA Office Hours: Thu 11:30–1:00 (ECSS 3.612)

Course Summary

This course covers 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. Theory and practice of Functional Programming (ML/OCaml): Students will learn the mathematical foundations and practice of implementing software in a functional programming style that leverages recursion and list-folding for loops, and immutable variables for program state.
2. Theory and practice of Logic programming (Prolog): Students will learn the mathematical foundations and practice of implementing search-based algorithms using a logic programming style that leverages backtracking and term unification to make progress through a search space.
3. Small-step and large-step operational semantics: Students will learn how to reason mathematically about computer programs using deductive logic extended with computational axioms.
4. Denotational semantics: Students will learn how to reason mathematically about computer programs using sets and functions.
5. Fixpoint theory: Students will learn the mathematical foundations of reasoning about loops in programs, including lattice theory, complete partial orders, and fixpoints.
6. Axiomatic semantics: Students will learn how to formally reason about high assurance systems using Hoare Logic and its mathematical foundations.
7. Type theory (simple, higher-order, and lambda cube): Students will learn how to extend type systems for programming languages to enable more powerful reasoning and higher assurance through higher-order (non-simple) types.
8. Untyped and typed lambda calculi: Students will learn how to encode functions and simple types as the mathematics of the lambda calculus, and use it to reason about functional programs.
9. Partial evaluation, non-determinism: Students will learn to leverage the types and semantics of first-class functions to reduce code bloat and write high assurance software, and improve robustness of non-deterministic, concurrent code.

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 formal, high-assurance software validation.

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

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

CLO Comparison with CS 4301

CS 6371 is cross-listed with an undergraduate-level course numbered CS 4301, which has reduced course learning objectives (CLOs). Students enrolled in CS 4301 are not responsible for or assessed on the additional CLOs specific to CS 6371. Here are how the CS 6371 CLOs differ from the ones for CS 4301:

1. Theory of Functional Programming (ML/OCaml): Students of CS 6371 will additionally learn the mathematical foundations of functional programming, including System F, lambda cube, and higher-order dependent type theory. Homework and exam questions on these subjects are not assigned to CS 4301 students.
2. Theory of Logic programming (Prolog): Students of CS 6371 will additionally learn the mathematical foundations of search-based logic programming. Homework and exam questions on these subjects are not assigned to CS 4301 students.
3. Small-step and large-step operational semantics: This CLO is the same for CS 4301 and CS 6371 students.
4. Denotational semantics: This CLO is the same for CS 4301 and CS 6371 students.
5. Fixpoint theory: Students of CS 6371 will additionally learn the mathematical foundations of reasoning about loops in programs, including lattice theory, complete partial orders, and fixpoints. Students of CS 4301 will not receive homework assignments or exam questions on this subject.
6. Axiomatic semantics: This CLO is the same between CS 4301 and CS 6371.
7. Type theory: Students of CS 6371 will additionally learn how to extend type systems for programming languages to enable more powerful reasoning and higher assurance through higher-order (non-simple) types. Homework and exam questions on these subjects are not assigned to CS 4301 students.
8. Untyped and typed lambda calculi: Students of CS 6371 will additionally learn higher-order lambda calculi. Homework and exam questions on these subjects are not assigned to CS 4301 students.
9. Partial evaluation, non-determinism: Students of CS 6371 will additionally learn to leverage the types and semantics of first-class functions to improve robustness of non-deterministic, concurrent code. Homework and exam questions on these subjects are not assigned to CS 4301 students.

To Prepare for the Course...

The first three classes are extremely important for succeeding in the remainder of the course; students are therefore urged to participate in the course from the start, by attending the first three classes in person. These initial classes will cover functional programming in the OCaml programming language, which will introduce many concepts assumed throughout the rest of the course. As mandated by the CS Dept Attendance Policy, missing the first 3 classes will result in an automatic deduction of one letter grade, and missing the first 4 classes will result in an automatic failing grade for the course.

To better understand the in-class OCaml demos, you should do the following as preparation:

• Download OCaml from the OCaml 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 OCPWin native Windows pre-compiled OCaml 4 installer.
  • Update: If the download page for OCPWin is offline, here is a pre-compiled Windows installer for 64-bit OCaml 4.02. When installing, be sure to change the install directory to C:\OCaml (which is not the default). Otherwise it may not install properly.
• Once you've successfully installed OCaml, try creating a simple program and compiling it. OCaml programs are plain text files, just like C/Java 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 some of the other examples found on Chapter 1 of the OCaml manual. Most of the 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 a 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 cs1.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;;

Grading

Homework (25%): Homeworks will be assigned approximately once per 1.5 weeks, and will consist of a mix of programming assignments and written assignments. Programming assignments will be implemented 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 1:05pm) on the due date. To help students prepare for the next assignment, homework solutions will typically be revealed on each due date. Therefore, no late homeworks will be accepted.

Quizzes (15%): On indicated assignment due dates (see the course schedule below), students will solve one or two problems individually at the start of class as a quiz. The quiz problems are essentially extra homework problems solved individually in class without the help of the internet or collaboration with other students. The quizzes will be closed-book and closed-notes.

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

Final (35%): A final exam for the course will be scheduled by the university registrar. 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 consult solution sets from previous semesters of this course, or collaborate with students who have such solutions. These sources are off-limits because such "collaborations" tend to involve simply copying or reverse-engineering someone else's answer to a similar homework problem, which does not prepare you for the quizzes and 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
  • 99 Practice Problems (with solutions) in OCaml
• Coq References:
  • The Coq Homepage
  • Software Foundations, by B.C. Pierce, et al.
• Operational & Denotational Semantics References:
  • The Formal Semantics of Programming Languages: An Introduction by Glynn Winskel (available from the UTD library)
  • Denotational Semantics: A Methodology for Language Development by David Schmidt, out of print but available online
• Type Theory References:
  • Types and Programming Languages by Benjamin C. Pierce
• Logic Programming Resources:
  • Logic, Programming and Prolog (2nd ed.) by Ulf Nilsson and Jan Maluszynski
  • SWI Prolog downloads and manuals

Tentative Course Schedule