CS422 - Programming Language Design (Fall 2013)

From FSL
Jump to: navigation, search

Students enrolled in this class are expected to check this web page regularly. Complete lecture notes will be posted here.

Course Description

CS422 is an advanced course on principles of programming language design. Major semantic approaches to programming languages will be discussed, such as structural operational semantics (various kinds), denotational semantics, and rewriting logic semantics. Programming language paradigms will be investigated and rigorously defined, including: imperative, functional, object-oriented, and logic programming languages; parameter binding and evaluation strategies; type checking and type inference; concurrency. Since the definitional framework used in this class will be executable, interpreters for the designed languages will be obtained for free. Software analysis tools reasoning about programs in these languages will also arise naturally. Major theoretical models will be discussed.

Meetings: Tu/Th 12:30 - 13:45, 1131 Siebel Center
Credit: 3 or 4 credits
Professor: Grigore Rosu (Office: SC 2110)
Office hours: 14:00 - 16:00 on Tuesdays (held by Grigore Rosu in SC 2110); also by appointment any other time (preferred).

Newsgroup

Web Interface to CS422

More info on newgroups at UIUC: https://news.cs.illinois.edu/

Lecture Notes, Useful Material

The links below provide you with useful material for this class, including complete lecture notes. These materials will be added by need.

  • Structural Operational Semantics 25px-Pdf_icon.png slides Info_circle.png
HW1 (due Friday, September 13) Downarrow.png

Exercise 1 (10 points): Modify IMP (its Big-Step and its Small-Step SOS) to halt when a division-by-zero takes place, returning a configuration holding the state in which the division by zero took place.

Exercise 2 (10 points): Add a variable increment construct, ++x (increment x and return the incremented value), to IMP: first add it to the formal BNF syntax, then to the Big-Step SOS, then to the type-system, and then to the Small-Step SOS.

Exercise 3 (10 points): Combine the two above: add both division-by-zero halting and an increment construct. Feel free to comment on what's going on, particularly on how inconvenient it is to do certain things in SOS (one fo the points of this HW is to understand the limitations of SOS, so you will appreciate K).

Exercise 4 (10 points): The current K LAMBDA semantics of mu (in Lesson 8) is based on substitution, and then letrec is defined as a derived operation using mu. Give mu a different semantics, as a derived construct by translation into other LAMBDA constructs, like we defined letrec in Lesson 7. To test it, use the same definition of letrec in terms of mu (from Lesson 8) and write 3 recursive programs, like the provided factorial-letrec.lambda.

Note: See the mu-derived exercise in the nightly built for details and test programs.


Note 1: Always download the nightly build of the K tool from http://kframework.org before any HW or project!!! The latest stable may be too old.

Note 2: I am still not decided what's the best way to auto-grade your HWs. I will provide the test examples soon, together with information on how auto-grading will proceed.

Note 3: Due to traveling, I was not able to setup the autograder yet. So for now please just put all your HW files in one zip folder. Have a subfolder for each exercise: ex1, ex2, ex3, ex4.

HW2 (due Friday, September 27) Downarrow.png

Exercise 1 (10 points): Modify the K definition of IMP to not automatically initialize variables to 0. Instead, declared variables should stay uninitialized until assigned a value, and the execution should get stuck when an uninitialized variable is looked up.

Note: See the uninitialized-variables exercise in the nightly built for details and test programs.

Exercise 2 (10 points): Mofify IMP so that the K "followed by" arrow, ~>, does not explicitly occur in the definition (it currently occurs in the semantics of sequential composition). Hint: make sequential composition strict(1) or seqstrict, and have statements reduce to "{}" instead of ".", ... and don't forget to make "{}" a KResult (you may need a new syntactic category for that, which only includes "{}" and is included in KResult).

Note: See the purely-syntactic exercise in the nightly built for details and test programs.

Exercise 3 (10 points): Define a variant of callcc, say callCC, which never returns to the current continuation unless a value is specifically passed to that continuation. Can you define them in terms of each other? Do these in both the substitution and the environment-based definitions.

Note: See the callCC (substitution), from-callCC-to-callcc (substitution), from-callcc-to-callCC(substitution), callCC (environment), from-callCC-to-callcc (environment), and from-callcc-to-callCC (environment) exercises in the nightly built for details and test programs.

Exercise 4 (10 points): The current "halt;" statement of IMP++ only halts the current thread. Define an "abort;" statement which halts the entire program. Write an IMP++ program which shows different behaviors when you replace one of its "halt;" statements with "abort;".

Note: See the abort exercise in the nightly built for details and test programs.


  • SIMPLE: Designing Imperative Programming Languages
HW3 (due Tuesday, October 15---deadline extended) Downarrow.png

Exercise 1 (10 points): Add "break;" and "continue;" to untyped SIMPLE. Just take the semantics of these from C/C++/Java, if uncertain. Do only the simple, unlabeled ones, which only break/continue the innermost loop. One thing to think about: do you still want to desugar the for-loop into a while-loop as we do it now?

Note: See the break-continue exercise for untyped SIMPLE in the nightly built for details and test programs.

Exercise 2 (10 points): Our current exceptions in SIMPLE are quite simplistic: the thrown exceptional value is caught by the innermost try-catch statement, and you get a runtime error (stuck) if the type of the thrown value is not the same as the type of the exception's parameter. They work fine if you restrict them to only throw and catch integer values, like we did in the static semantics, but modern languages do not like this limitation. Change the existing dynamic semantics of typed SIMPLE to propagate a thrown exception to the outer try-catch statement when the inner one cannot handle the exception due to a type mismatch. For example, "try { try { throw 7; } catch(bool x) {print(1};} } catch{int x) {print(2);}" should print 2, not get stuck as it currently happens.

Note: See the typed-exceptions exercise for dynamically typed SIMPLE in the nightly built for details and test programs.

Exercise 3 (10 points): Same as Pb2, but for the static semantics of the typed SIMPLE. For this exercise (but not for the previous one), modify also the syntax of SIMPLE to allow functions to declare what exceptions they can throw.

Note: See the functions-with-throws exercise for statically typed SIMPLE in the nightly built for details and test programs.

Exercise 4 (10 points): Compilers typically collect all the variables declared in a block and move them all in one place, renaming them appropriately everywhere to avoid name conflicts. Consequently, they do not like you to declare a variable twice in the same block. Modify the static semantics of SIMPLE to reject programs which declare the same variable twice in a block. Your resulting type system should get stuck when a variable is declared the second time.

Note: See the no-duplicate-declarations exercise for statically typed SIMPLE in the nightly built for details and test programs.

For each of the problems, also provide one test program which should succeed and one which should fail. You will get two extra-points if any of your tests break everybody's definition (except potentially yours). If you handle more than one succeeding and one failing test, then I will randomly choose one of each.


  • KOOL: Designing Object-Oriented Programming Languages
HW4 (due Tuesday, October 29) Downarrow.png

Exercise 1 (10 points): Currently, all class members (fields and/or methods) are public in KOOL. Sometimes we want to keep members of a class private, in the sense that subclasses do not have direct access to those members. This exercise asks you to add private members to untyped KOOL. Syntactically, you should allow a new keyword, "private", to optionally prepend member declarations. For example, "private var x=10, y=10;" or "private method f(x,y) {...}".

Note: See the private-members exercise for untyped KOOL in the nightly built for details and test programs.

Exercise 2 (10 points): Same as Exercise 1, but for dynamically typed KOOL.

Note: See the private-members exercise for dynamically typed KOOL in the nightly built for details and test programs.

Exercise 3 (10 points): Same as Eercises 1 and 2, but for statically typed KOOL.

Note: See the private-members exercise for statically typed KOOL in the nightly built for details and test programs.


  • FUN: Designing Functional Programming Languages
  • FUN untyped (Part 9 of the K Tutorial, without the type inferencer)
HW5 (due Tuesday, November 12) Downarrow.png

Exercise 1 (10 points): Add a "let*" construct to environment-based FUN. "let*" has the same syntax as "let", but it applies the bindings in the order in which they are given. For example, the program "let* x=1 and y=x in y" is well defined and evaluates to 1, but it would be undefined if we replaced "let*" with "let".

Note: See the letstar exercise for details and test programs.

Exercise 2 (10 points): Add interactive "read" and "print" to environment-based FUN.

Note: See the io exercise for details and test programs.

Exercise 3 (10 points): Add thread creation, with "spawn", and synchronization, with "join", to environment-based FUN.

Note: See the spawn-join exercise for details and test programs.

Exercise 4 (10 points): Extend the semantics of "letrec" in substitution-based FUN, which currently can only take one binding, to arbitrarily many bindings.

Note: See the letrec exercise for details and test programs.


HW6 (EXTENDED: due Friday, Dec 6) Downarrow.png

This HW has only one exercise, but remember that all HWs have equal weight. The exercise is to develop a let-polymorphic type inferencer for FUN. Use the existing syntax of FUN. If correct, your type inferencer should type all the existing FUN programs.

You are only required to do it using the explicit-constraint style, like in 1_k/5_types/lesson_9 (this is more stable than the implicit constraint style shown in lesson 9.5).

Several students asked me about extracredit problems. Here is one (50% of a regular HW, but it counts only if you solved correctly and completely HW6): Same as HW6, but using the implicit constraint style (so it should run with the option --backend java). Here is another one (50% of a regular HW, but it also counts only if you solved correctly and completely HW6): Explain why the type inferencer in HW6 is unsound w.r.t. references (yes, it is unsound!), and fix it.

Note: See the fun-type-inferencer exercise for details and test programs.


  • LOGIK: Designing Logic Programming Languages
  • Logik (Part 10 of the K Tutorial)
HW7 (due Thursday, Dec 12) Downarrow.png

This HW has only one exercise, but remember that all HWs have equal weight. The exercise is to extend LOGIK with several features.

Note: See the LOGIK extended exercise for details and test programs.

  • Lambda Calculus and Combinatory Logic 25px-Pdf_icon.png slides Info_circle.png
Personal tools
Namespaces

Variants
Actions
Navigation