Available from January 26, 2020 until July 3, 2020

Course: CSE2120 Edition: 2019-2020

One can enroll until Thu, Apr 2, 2020 12:00:00
Course staff
  • Casper Poulsen
  • Eelco Visser
  • Ali Al-Kaswan
  • Yana Angelova
  • Wesley Baartman
  • Kirti Biharie
  • Philippos Boon Alexaki
  • Luc Everse
  • Boris Janssen
  • Rembrandt Klazinga
  • Mirco Kroon
  • Chris Lemaire
  • Sterre Lutz
  • Yaniv Oren
  • Wouter Polet
  • Thijs Raijmakers
  • Jim van Vliet
  • Yoshi van den Akker
  • Paul van der Stel
  • Eric van der Toorn
2.1. Course Contents and Study Goals

The design of a programming language is the result of a selection from a general collection of programming language concepts. With some frequency, new languages are introduced that combine concepts in a novel manner and sometimes introduce new concepts. During their careers, computer scientists will have to work with more than one generation of programming language. In order to learn new programming languages, a computer scientist should understand the basic principles in the design of programming languages. In this course we study these principles.


The topics covered in the course include:

  • Syntax and interpretation: programs as data, abstract vs. concrete syntax, interpretation

  • Functional programming: higher-order functions, lexical scope, function closures, currying and partial application, functions over data (especially map, fold, and filter).

  • Mutation and memory: implementing loops and recursion, tail calls, heap memory allocation and reuse.

  • Lazy evaluation and infinite streams: lazy vs. eager evaluation, thunks, streams, memoization.

  • Types: a type as a set of values together with a set of operations, primitive types, compound types, type safety and errors caused by inconsistent use of values, association of types to names, type checking, type inference.

  • Objects and encapsulation: privacy and visibility of class members, interfaces revealing only method signatures, inheritance, subtyping.

Study Goals

By the end of this course, you will be able to:

  1. Use algebraic data types and pattern matching to implement a definitional interpreter for a programming language concept.

  2. Use a modern high-level programming language such as Scala to implement, test, and debug definitional interpreters and type checkers for languages with simple types.

  3. Define example and counter-example programs that use a programming language concept correctly and incorrectly; for example, variables and lexical scope in a program using function closures.

  4. For multiple programming languages, identify program properties checked statically and program properties checked dynamically.

  5. Discuss how programming concepts interact with the definition and implementation of other language features.

  6. Describe trade-offs of the functional approach (defining a function for each operation with the function body providing a case for each data variant) and the object-oriented approach (defining a class for each data variant with the class definition providing a method for each operation).