Skip to content

Course Organization


The first half of the course introduces functional programming through the Haskell programming language, while the second half covers imperative and concurrent programming via the Rust programming language. Sprinkled throughout at Core lectures---marked with a (C) on the calendar---where we develop a simplified, mathematical model of the language being considered.

Attending lectures is absolutely critical.

Slides will be made available after lectures, but they be difficult to understand in isolation. Readings will cover some---but not all---of the course material. While there will be no attendance component in the grading, it will be extremely challenging to master the material if you do not come to class.


Most lectures are paired with a reading. These are optional and classes will not exactly follow the readings, but you will get more out of the lectures if you skim the readings beforehand (or afterwards). Readings will be drawn from these three books:

You are welcome to buy physical copies if you wish---they're good books!---but the online versions will suffice for this course.

Here are a few more texts, giving an different perspective on the main material:

These shorter readings talk about programming languages in general:

Learning Outcomes

By the end of this course, you should be able to...

  • Program at an intermediate level in Haskell: use functional programming idioms, user-defined datatypes, typeclasses, and monads; control side-effects and mutation.
  • Program at an intermediate level Rust: use imperative programming idioms, analyze ownership and borrowing, and implement safe concurrent applications.
  • Mathematically specify programming languages in various complementary ways: syntax and grammar, operational semantics, type systems.

Credit Information

This is a 3-credit course for advanced undergraduates and beginning graduate students. We will meet for two 75-minute class periods each week over the spring semester, and you should expect to work on course learning activities for about 3 hours out of classroom for every class period.

Curriculum Standards

We plan to cover the following topics from the recent 2013 ACM/IEEE Computer Science Curricula Guidelines:

  • PL/Functional Programming
  • PL/Basic Type Systems
  • PL/Program Representation
  • PL/Concurrency and Parallelism
  • PL/Type Systems

In addition, we will touch on parts of the following topics:

  • PL/Language Translation and Execution
  • PL/Syntax Analysis
  • PL/Advanced Programming Constructs
  • PL/Formal Semantics


Homeworks will have two parts: a programming lab where you will gain concrete experience working with the two main languages, and a written component to give you practice working with the mathematical core languages. There will be six homeworks in total, issued roughly every two weeks. Homeworks will generally be posted after lecture, and are due roughly two weeks later before lecture. Keep an eye on the calendar!

Late homework will not be accepted---we will not have a late day policy. Instead, your lowest homework score will be dropped. Limited partial credit is possible for partial homework solutions.

There will be two "checkups" for helping you get familiar with your Haskell and Rust installations. These will not count towards your homework grades, but you should complete them and turn them in.

Midterm and Final exam

The midterm exam will be held during the regular class slot on March 5. It will be a written test about Haskell and functional programming. We will give you some reference sheets during the exam, stay tuned.

The final exam will cover all of the material in the course. The final exam slot is 2:45-4:45, May 9. There is no make-up date.

Grading Policy

Your grade will be based on these components:

  • Homeworks: 65%
  • Midterm Exam: 10%
  • Final Exam: 20%
  • Participation: 5%

Your lowest homework score will be dropped.

Important Disclaimer

This is my first time teaching CS 538, and almost everything else will also be new:

  • Materials. The previous edition of this course was taught nearly ten years ago. Lectures, homeworks, labs, and exams are being piloted for the first time.
  • Languages. Haskell and Rust are cutting-edge languages that are both evolving at a tremendous rate (there is a new version of Rust every six weeks). We will stick to stable software and try to avoid breakages; beware of out-of-date notes.
  • Course design. This course aims to cover a lot of material, weaving between hands-on experience and mathematical models of modern programming languages. This kind of course is not exactly new, but also not common.

I will do my best to make the course run as smoothly as possible, but the road may get a bit bumpy at times---things may break, the pace may be too fast/slow, the schedule may need to be adjusted, etc. I am reserving one overflow slot at the end of each half, in case we end up taking more time on some topics.

If something is not working, please let me know ASAP and I will try to fix it.

Access and Accommodation

The University of Wisconsin-Madison supports the right of all enrolled students to a full and equal educational opportunity. The Americans with Disabilities Act (ADA), Wisconsin State Statute (36.12), and UW-Madison policy (Faculty Document 1071) require that students with disabilities be reasonably accommodated in instruction and campus life. Reasonable accommodations for students with disabilities is a shared faculty and student responsibility. Students are expected to inform me of their need for instructional accommodations by the end of the third week of the semester, or as soon as possible after a disability has been incurred or recognized. I will work either directly with you or in coordination with the McBurney Center to identify and provide reasonable instructional accommodations. Disability information, including instructional accommodations as part of a student’s educational record, is confidential and protected under FERPA.