CS 421: Programming Languages and Compilers

Note: You can find the complete set of questiosn in a pdf, and a tarball containing a testing harness for the question set at the link in the first column (topic). You can practice the experience of using PrairieLearn to do and submit you work but following the link in the second colunm, and selecting the assessment of the name given n the second column.
Machine Labs for Fall 2019
Topic PrairieLearn Practice Name Issued Lab Start Date Lab End Date
ML1 OCaml: Basic OCaml Practice Machine Lab 1: OCaml: Basic OCaml Monday, Aug 26 Tuesday, Sep 3 Friday, Sep 6
ML2 Pattern Matching and Recursion Practice Machine Lab 2: Pattern Matching and Recursion Saturday, Sep 7 Tuesday, Sep 10 Friday, Sep 13
ML3 Higher-Order Functions and Continuation-Passing Style Practice Machine Lab 3: Higher-Order Functions and Continuation-Passing Style Friday, Sep 20 Tuesday, Sep 24 Friday, Sep 27
ML4 A Unification-Based Type Inferencer Practice Machine Lab 4: A Unification-Based Type Inferencer Friday, Oct 18 Tuesday, Oct 22 Friday, Oct 25
ML5 A Lexer for PicoML Practice Machine Lab 5: A Lexer for PicoML Friday, Nov 1 Tuesday, Nov 5 Friday, Nov 8
ML6 A Transition Semantics Evaluator for CPS Practice Machine Lab 6: A Transition Semantics Evaluator for CPS Friday, Dec 6 Sunday, Dec 8 Wednesday, Dec 11

Note: The late penalty is 20% of the total number of points on the base part of the assignment, plus 20% of the total points possible on the extra credit, if you attempt the extra credit. It is not 20% of the number of points you earn.

Machine Problems for Fall 2019
Topic: Issued: Due at 22:00 CT (10:00pm CT) on: Automatic extension
(with 20% penalty)
until 22:00pm CT (10:00pm CT) on:
MP1 Patterns of Recursion, Higher-order Functions Friday, Sep 13 Friday, Sep 20 Sunday, Sep 22
MP2 Working with ADTs: Implementing CPS Transformation Friday, Sep 27 Friday, Oct 4 Satuday, Oct 6
MP3 Unification Algorithm Friday, Oct 25 Fri, Nov 1 Mon, Nov 4 Sun, Nov 3 Wed, Nov 6
MP4 A Parser for PicoML Friday, Nov 8 Friday, Nov 22 Sunday, Nov 24
MP5 An Evaluator for PicoML Friday, Nov 23 Friday, Dec 6 Sunday, Dec 8

Web Assignment (WA) Problems for Fall 2019
Topic: Issued: Due at 22:00 CT (10:00pm CT) on: Automatic extension
(with 20% penalty)
until 22:00 CT (10:00pm CT) on:
WA1 Evaluation and Evironments Friday, Aug 30 Monday, Sep 9 Wednesday, Sep 11
WA2 Evaluating the Application of a Function TBA TBA TBA
WA3 Order of Evaluation TBA TBA TBA
WA4 CSP Transformation; Working with Mathematical Specifications TBA TBA TBA
WA5 Algebraic Datatypes TBA TBA TBA
WA6 Polymorphic Type Inference Monday, Oct 14 Monday, Oct 21 Wednesday, Oct 23
WA7 Incremental Unification Algorithm Monday, Oct 21 Monday, Oct 28 Wednesday, Oct 30
WA8 Regular Expressions Monday, Oct 28 Monday, Nov 4 Wednesday, Nov 6
WA9 Parse Trees, Ambiguous Grammars and Recursive Descent Parsing Monday, Nov 4 Monday, Nov 11 Wednesday, Nov 13
WA10 Natural and Transition Semantics Monday, Nov 11 Monday, Dec 2 Wednesday, Dec 4
WA11 Lambda Calculus TBA TBA TBA
WA12 Hoare Logic TBA TBA TBA

Signing Up for a Machine Lab

To sign up for a time slot to complete your Machine Lab, do the following:

  1. You can sign up for a time slot to complete your Machine Lab by going to https://cbtf.engr.illinois.edu.
  2. If you do not see CS 421: Programming Languages as one of your courses, you should click Add a course, and then select CS 421: Programming Languages.
  3. Once you have CS 421: Programming Languages added to your courses, select the appropriate Machine Lab that you wish to sign up for.
  4. You should now be able to select a timeslot from those available to go to the testing facility and complete your Machine Lab. Please contact the instructor if you have a conflict as defined by university policy.

Machine Lab Logistics

There are certain things to remember when you're about to go complete a machine lab:

  • The testing facility is located in the basement of Grainger Library, room 057.
  • You have 50 minutes to complete your Machine Lab (as per the CBTF policy).
  • You will be using PrairieLearn, an online testing suite, to obtain your starter file and submit your solutions. If you have difficulties and thing something is wrong, you need to speak to the proctor and file a report. Your report will be given to the course staff.
  • PrairieLearn works only on Firefox and Chrome. Don't use any browser other than those.
  • You will be provided with scratch paper (which you will turn in before you leave).
  • You will be able to, like on MPs, make and test your code against the grader.
  • If you are unable to make a scheduled ML and could not reschedule it, talk to the proctor in the CBTF, and explain what happened, and request to reschedule.
IMPORTANT

You must bring ONLY your iCard and optionally, a writing utensil. Your iCard will be checked and scanned at the testing facility.

You are NOT allowed to bring backpacks or electronic devices (including watches, cellular devices, etc.) to your workstation. There are shelves at the enterance where a bag may be placed, but the CBTF staff are not respoonsible for its safekeeping..

You can find more information on the procedures and policies of the Computer-Based Testing Facility here.


Working on a Machine Lab

While you are completing your Machine Lab, you will have access to the following materials:

  1. PrairieLearn
  2. The starter files we have provided you with (including files to make a grader)
  3. A text editor
  4. OCaml
  5. make

You may want to review the Guide for Doing MPs and the instructions on Interactive Debugging prior to going to the testing facility.

Instructions will be provided on each question on how to untar and complete each question. For completeness, we have included them here as well.

Instructions on Machine Lab Questions
  1. Download the starter file, located here.
  2. Untar the starter file. This can be done in one of two ways:
    • In your terminal, locate the downloaded starter file, then execute tar -zxf $QUESTION.tar.gz.
    • Using a GUI, untar the starter file.
  3. After untarring, a directory will be created named $QUESTION. (e.g. twoPair)
    • Within the directory are the usual files you can use to make a grader, including an extensive set of tests.
    • We reserve the right to make changes to the provided test suite or run additional tests on submitted code.
  4. Complete the problem below in $QUESTION.ml.
    • If you need to start from scratch, you should make a copy of $QUESTION-skeleton.ml and rename it $QUESTION.ml.
  5. When you have finished the problem and tested it thoroughly, cut and paste the contents of $QUESTION.ml file into the PrairieLearn editor window for the problem. (Note that submitting WA problems may result in your grade being 0%; such a grade on PrairieLearn generally only indicates question completion.)

Instructions for Submitting Assignments
  • For a WA, the assignment will be available through PrairieLearn and will be collected there. You can optain the pdf writeup and tarball for each ML and MP at the links given above. You can also obtain them through PrairieLearn, and the MPs may be submitted there. The MLs are
  • When you retrieve an MP or ML via the above links, you will be able to collect a pdf named mpX.pdf or mlX.pdf giving background information describing the work to be done for the assignment. You will also be able to collect a tarball named mpX.tar.gz or mlX.tar.gz. You can unpack the tarball with
    tar -xzf mpX.tar.gz
    or tar -xzf mpX.tar.gz
    as approriate. The resulting directory added will contain the pdf for the assignment, a file with a name (typically mpX.ml or mlX.ml) and infrastructure to help you test your code. The file mpX.ml or mlX.ml is just a stub. To test, you need to delete or comment out the stub code and add your own. The next section Guide for Doing MPs contains further information about how to test your code.

    MPs, like WAs, will be turned in by entering your answer into text windows (typically one per problem) in PrairieLearn.

    Before submitting an MP assignment, you MUST make sure that your MP compiles with the student grading script supplied with the assignment. If your MP fails to compile with the student grading script, your assignment will get NO CREDIT. There will be no partial credit for assignments that fail to compile.

    For each ML, we give you the whole set of problems before you need to go to the lab to be checked on them. Typically, in the lab you will be asked to do only a fraction (typicaly about a fifth, but may be smaller or larger) of the problem(s) you were given in the pdf. You may go to PrairieLearn to take sample runs of the lab before going to the Computer-Based Testing Facility (CBTF), but only the version of your work you submit in the CBTF will count for your grade. The code you submit in the CBTF must compile to receive credit for it. You will have access to the ocaml compiler and the test suite for you to check before you submit. The next section Guide for Doing MPs is useful for preparing for MLs as well as doing MPs.

  • You may do multiple commits of either the MPs or the WAs. Work submitted before the late deadline will not be subject to the late penalty, but work submitted after will.
Guide for Doing MPs
A guide for how to attack an MP:
  1. In your svn repository dircetory, or its subdirectory assignments, do an svn up to retrieve the directory mpX for the MP and all its contents. Go into that directory. (If we need to revise an assignment, you will need to repeat the svn up to obtain the revision.)
  2. To make sure you have all the necessary pieces, start by executing make. This will create the grader executable. Run the executable (./grader). Examine the failing test cases for places where errors were produced by your code. At this point, everything should compile, but the score will be 0.
  3. Read and understand the problem for the handout on which you wish to begin working. (Usually, working from top to bottom makes most sense.) There is a tests file in this directory. This is an important file containing the an incomplete set of test cases; you'll want to add more cases to test your code more thoroughly. Reread the problem from the handout, examining any sample output given. Open the tests file in the mpX directory. Find the test cases given for that problem. Add your own test cases by following the same pattern as of the existing test cases. Try to get a good coverage of your function's behaviour. You should even try to have enough cases to guarantee that you will catch any errors. (This is not always possible, but a desirable goal.) And yes, test cases should be written even before starting the implementation of your function. This is a good software development practice.
  4. If necessary, reread the statement of the problem once more. Place your code for the solution in mpX.ml (or mpX.mll or mpX.mly as specified by the assignment instructions) replacing the stub found there for it. Implement your function. Try to do this in a step-wise fashion. When you think you have a solution (or enough of a part of one to compile and be worth testing), save you work and execute make and the ./grader again. Examine the passing and failing test cases again. Each failure is an instance where your code failed to give the right output for the given input, and you will need to examine your code to figure out why. When you are finished making a round of corrections, run make, followed by ./grader again. Continue until you find no more errors. Consider submitting your partial result so that you will at least get credit for what you have accomplished so far, in case something happens to interfere with your completing the rest of the assignment. You can submit one problem at a time in earlier assignments. In later assignments, problems tend to be pieces of functions. It is still worth your while to incremental uploads.
  5. When your code no longer generates any errors for the problem on which you were working, return to steps 3) and 4) to proceed with the next problem you wish to solve, until there are no more problems to be solved.
  6. When you have finished all problems (or given up and left the problem with the stub version originally provided), you will need to submit your code to PrairieLearn.

Interactive Debugging
In addition to running "make" and "grader", you probably want to test and debug your code interactively at the top level:
  1. Enter the directory with your source file.
  2. Type ocaml at the command line.
  3. Type #load "common.cmo";; at the OCaml prompt, where X is the number of the assignment (this loads in the common stuff that we give you in compiled form by default).
  4. Type #use "mpX.ml";; at the OCaml prompt, where X is the number of the assignment. This loads in your code, and adds the functions you have defined to the identifiers recognized at top level.
  5. Type in commands followed by ';;' at the OCaml prompt to test your code interactively. Anything that you can do in a code file, you can do interactively. For example, you can define identifiers using 'let x = ...', etc...
  6. With each MP, you will be given a solution in compiled form. You may interactively test the solution to a problem, after having loaded "common.cmo", by loading the solution file by typing #load "solution.cmo";;. After that, if you are supposed to write a function called, say splat, and wish to find out what it does on an input, say 39.2, you may execute the solution's version of splat by typing Solution.splat 39.2;;. Notice the capitalization.