CSC 430, Spring 2020
1 Spring 2020 Special Note
2 Spring 2020 Team Submissions
3 About the Course
4 Learning Outcomes
4.1 Bonus Topics
5 Prerequisites
6 Names, Times, Locations
6.1 Instructor
6.2 Lecture & Lab
6.3 Google Calendar
6.4 Web Page
7 Lecture Classroom, Spring 2020
8 Computing Environment
9 Version Control
9.1 Typed Racket
9.2 Installing the Handin Server
10 Readings
10.1 plai-typed and typed/  racket
11 Communication
12 Honesty
13 Labs
14 Assignments
15 Grading Code
15.1 Code Organization
15.2 "But it Works!"
15.3 Grading Time Limit
15.4 Grading code in 430
15.5 Common Errors
16 Interacting with the Handin Server
17 Quizzes and Exams
18 Grades
19 Checking your Grade
7.7.0.4

CSC 430, Spring 2020

1 Spring 2020 Special Note

We’re going to do the best we can, under the circumstances. The goals of the course are similar, but we’re definitely not going to be able to cover all of the material that we would ordinarily cover in this course. Also, I’m going to ask for your patience as we sort out what works and what doesn’t, and I foresee having to change various aspects of the course as we go along. By the same token, it’s incumbent on me to have patience with you, to bear with whatever the circumstances of your life are. My goal, as always, is to help you learn as much as I can reasonably expect.

2 Spring 2020 Team Submissions

This quarter, we’re working in teams of three. You are not required to submit together with your teammates, if you’re working on your assignments totally independently, but you’re encouraged to work together and submit together.

In order to submit as a team using the CSC430 handin plugin, you need to specify all of the user ids in the "username" box, separated by pluses. So, for instance, if I were submitting with Ichabod Crane and Florence Nightingale, I might put

  clements+icrane+fnighti

... in the username box. The ordering of the names doesn’t matter; putting the names in a different order puts the submission in the same "box".

After you’ve done this, it’s not possible to submit individually. That shouldn’t be a problem; if you want to try out a fix or submit your own changes to see how it affects your score, just go ahead and do that; your team can always submit again to revert to the old version.

3 About the Course

Programming languages determine what programs we can write. Languages with nice abstractions allow us to write elegant, concise, and readable programs.

In this class, we’ll start from scratch, and build a programming language by adding only what’s necessary. What we’ll discover is that this simplistic approach leads to some really powerful abstractions. You can do more with less!

At the end of the course, you should be a better programmer. You should also have a clearer picture of a given language as a choice in a larger design space, and be better able to understand new programming languages and the similarities between them. Finally, you may develop some taste for what you like in a programming language.

This course will involve lots of programming in Racket. I choose Racket for several reasons. First, “functional” programming languages make this kind of course feasible. Writing a series of interpreters in another language would probably involve a whole lot more code. Secondly, Racket is a simple language for you to learn, without complex syntactic rules or a confusing type system. Thirdly, the simplicity of Racket makes it an ideal “blank slate” for adding features. If these reasons don’t make sense to you, then... perhaps you need to take the course!

4 Learning Outcomes

Here are the course outcomes that I’m striving for:
  • You can write programs in a largely functional language (i.e. ML, Racket).

  • You can identify expressions and other syntactic elements of a language that you know or are learning.

  • You can perform simple parsing by hand, transforming textual strings into abstract syntax trees.

  • You can apply standard reduction rules for the following language forms to compute the results of programs, including these forms:
    • arithmetic & other primitive function applications

    • function calls / variable references

    • mutation forms

  • You can write programs to produce these same results (a.k.a. interpreters), up to families of similar reduction rules.

  • You understand the relationship between substitution and environments, and can model a computation’s progress using either model.

  • You understand the notion of scope induced by these rules, and can identify and reason about the bindings and bound variables in arbitrary programs.

  • You have a limited ability to read and understand programs written in store-passing style.

  • You have a limited ability to transform code using mutation into purely functional code, using store-passing style

  • You can apply the rules of a type-checker (given as Gentzen-style natural deduction rules) to determine whether a program satisfies a type system.

  • You can explain why these systems work the way they do, and have a limited ability to consider variations of these systems and how such variant systems would behave.

4.1 Bonus Topics

We usually get to one of these:

5 Prerequisites

In order to take this course you must be able to design and implement small programs (~ 1 KLOC) efficiently. You must have a basic understanding of mathematics and data structures. You should be able to reduce arithmetic expressions by hand, in a small-step style (that is, one step at a time). You should be able to identify statements and expressions in a programming language such as Java, Python, or C.

6 Names, Times, Locations

6.1 Instructor

6.2 Lecture & Lab

Section 03/04:

Section 07/08:

6.3 Google Calendar

See my home page for my calendar. You can add it to your calendar, if that makes your life easier.

Office hours also appear on this calendar; you may find them easier to see if you click on the "week" tab of the calendar.

6.4 Web Page

This is the course web page, its link is https://www.brinckerhoff.org/clements/2204-csc430/.

7 Lecture Classroom, Spring 2020

Hmm... I think the "no laptops" rule isn’t going to work well, this quarter.

I do think that engagement is going to be a huge challenge; you’re almost certainly going to be engaging with the classroom through a small rectangular picture and a pair of headphones, which is a totally different experience from actually being there in a classroom.

My plan is to split the class into smaller mini-classes of 9 students. I’m not sure how well this will work out, really. We’ll talk about this in our first class meeting.

8 Computing Environment

You will be required to complete the assignments in this class using Racket, version 7.6 or later. It is freely available for all major platforms, including Mac OS, Windows, and UNIX.

Most of you will probably want to use the IDE, DrRacket, which is a part of this package.

9 Version Control

Version control is important in this class and every class in which you write programs of more than 50 lines. I personally use private git repos on both github and bitbucket. Remember, it’s not whether you lose data, but when. For Heaven’s sake, though, make sure they’re private repos. (See the Honesty section, below)

9.1 Typed Racket

We’re going to be using the Typed Racket language for this course. Typed Racket is a ground-breaking type system that uses "occurrence typing" to allow union types in a statically typed language in a computationally tractable way. See this paper for details, if you’re interested. This type system originated in Racket, but is now used in a variety of gradually typed languages, such as TypeScript.

Also, there are a variety of introductions to Racket and/or Typed Racket that may be useful to you:

Also, in order to simplify the task of writing in Typed Racket, I’ve written up some Hints on Using Typed Racket in CSC 430.

Finally, here are some Helpful Tidbits.

9.2 Installing the Handin Server

In order to hand in your work, you’ll need a plugin.

Now, you should be ready to hand in.

10 Readings

The majority of the readings in this course will be from Programming Languages: Application and Interpretation, second edition, by Shriram Krishnamurthi.

The first two weeks may also include readings from How To Design Programs (also known as "HtDP"), available free online.

10.1 plai-typed and typed/racket

We will be writing our code in this class in the frighteningly awesome typed/racket language. The textbook is written using the plai-typed language. There are differences. In order to make your lives slightly less difficult, I’ve translated the code from the first few chapters from plai-typed to typed/racket to make them more applicable to your code.

./CodeFromClass/PLAI-TR-translation.rkt

11 Communication

This class will use Piazza. This will be the principal means that I’ll use to notify you of deadlines, organizational updates, and changes to assignments. If you’re not keeping up with the group, you’re going to be missing important information.

It’s also the best way for you to direct questions to me and/or the class. Feel free to e-mail me with personal questions, but use the Piazza group as your main means of communication. It’s possible to post anonymously, if you like.

You should already have received an invitation to the Piazza group; let me know if you need an invite.

Don’t post your code or test cases to the group; anything else is fair game.

Also, please keep in mind that I (and everyone else) judge you based in part on your written communication. Spelling, complete sentences, and evidence of forethought are important in all of your posts & e-mails. One easy rule of thumb: just read over what you’ve written before clicking post or send, and imagine others in the class reading it.

12 Honesty

We strongly encourage collaboration among students in almost every aspect of the course. See, for example, the following section on "Labs", which are designed for collaboration.

The exception is for programming assignments: you may not copy another student’s code, not even test cases. You are also responsible that no other students see your code, either during this course or afterwards, either deliberately or through negligence (e.g. via a non-private repo).

A very effective automated tool will review submissions for evidence of copying. Students believed to be cheating, i.e. both parties involved in a transfer of code, will in the first instance typically receive a 0 score for the assignment. We reserve the right to assign a failing grade in the class when appropriate.

13 Labs

Labs in this course take the form of simple exercises to be completed in a week during lab periods, designed to help you understand the lecture material and to lead you toward solutions for the larger assignments.

I’ll be checking these off during the lab; you’re responsible for demo-ing your lab solutions for me. Your marks on these labs will be simple credit/no-credit.

The labs will be due at the end of your lab period on the day specified, typically Friday. If we run out of time to check them, I will generally elect to accept them during the following lab session, but you cannot rely on this occurrence; the labs are due on the day specified on the schedule.

In labs, you are heartily encouraged to collaborate like crazy. Look at everyone else’s code, copy and paste, type on your neighbor’s keyboard, whatever. Labs need not be entirely your own work.

When you successfully demonstrate a lab, I will give you a number. You may enter these numbers at http://brinckerhoff.org:8026/servlets/standalone.rkt (also linked from the top of this page).

14 Assignments

Programming assignments will be due at 10:00 PM. You must submit homework assignments using the Handin button in DrRacket. Late assignments will not be accepted.

From time to time, we may examine student code in lecture. Try to ensure that the code you submit is something you’d be proud to show to the others in the class.

Late Policy: Except for exceptional circumstances, late assignments will be given 0 points.

15 Grading Code

I will be grading your code repeatedly in this class. On most assignments, your score will consist of a part (usually 20 points) based on your performance on a set of test cases automatically administered by the handin server, and a part (usually 6 points) based on my opinion of your code’s clarity, organization, and adherence to rules about purpose statements and contracts/types (in short: you’ve got to have them). As a rule, my "eyeball" score rubric runs something like this:

Finally, please note that I will place comments in some of your submissions indicating errors or stylistic requests. These will all begin with the string ;;> (in Racket) or ##> (in Python), so you can search for these in the e-mail that you get with your final assignment grade.

15.1 Code Organization

Here’s the most important thing to know about code in this class: I do actually read it. That means that—like most code you’ll write in industry—it neads to be readable and clear. If your code isn’t predictable and understandable, it will be ripped out and replaced, probably by someone who’s grumpy.

This means that getting your code to work is not the end of the process; after you get your code to work, you have to clean it up, put nice headers on the various parts, collect the test cases, document strange things that you did, and clarify the code.

You should begin with a single-paragraph comment that describes how far you got: did you finish, or did you get stuck on something? If you got stuck, describe what’s done and what’s still left to implement.

As a rule, I like to read code in a "top-down" way. This means that the definition of the top-level, important functions should come first, and the supporting functions should come later. I want to have a good understanding of the big picture before getting into the details. My experience is that if interp makes sense, then add-to-env will probably not present any difficulty.

Another part of cleaning up the code is collecting the test cases in a place that’s sensible and doesn’t interrupt the flow of reading the code. It’s probably best–after you’re done writing the code–to collect the test cases at the bottom of the file (or put them in another file altogether, if appropriate).

Whatever language you use, it’s likely to have a style guide. Here’s the one for Racket. You’re not required to follow any style guide, but anything that makes your code hard to read could hurt your score.

Finally: dead code is misleading and makes code hard to read. Delete it.

15.2 "But it Works!"

I reserve the right to assign bad scores to programs that work correctly; if I don’t think you’re doing a good job of programming, then you won’t receive a good score. "It works" isn’t a defense for bad code.

15.3 Grading Time Limit

Good code is easy to read. I reserve the right to allocate a fixed period of time to grading a program submission. Don’t be surprised to see comments like "ran out of grading time here."

Naturally, all grades contain an element of subjectivity.

15.4 Grading code in 430

For most of the assignments in this class, I’ll expect to see these things at the top, in this order:
  • Types and Data Structures,

  • the definition of top-interp,

  • the definition of interp, and

  • the rest of the program.

Per the style guide, please don’t follow the "one closing brace per line" style that’s common in Java and C; your Racket code will be reasonably deeply nested, and this convention causes such programs to consume huge amounts of vertical space.

15.5 Common Errors

Also, see my discussion of specific common errors in this class.

16 Interacting with the Handin Server

You will be handing in your work in this class using a plugin for DrRacket that communicates with a handin server running remotely. From past experience, there are several things that may not be obvious about your interactions with this server.

17 Quizzes and Exams

My experience suggests that frequent quizzes are a good way to ensure that you’re understanding what I’m teaching, and that I’m teaching things that you understand.

This class will have quizzes on Wednesdays, probably during the first six or seven weeks of the class. These quizzes will probably be fifteen minutes long, and will probably take place during lab.

There will be a midterm and a final exam in the course. The midterm will be during the lecture period in the sixth week of class. The quizzes and exams will be closed-note. No electronic devices, including calculators, phones, or mp3 players, will be permitted during the quizzes or exams.

18 Grades

Grades will be determined by performance on programming projects, the exams, and class interaction. A small fraction of the grade is determined by the labs, and by the instructor’s whim. The breakdown of the grade is as follows:

19 Checking your Grade

I like to share your current grade in the class with you. It usually takes me a few weeks to get this set up, but you should eventually be able to check your student grade at

https://users.csc.calpoly.edu/~clements/student-grades/<your-login>/current-grade.txt

That’s not a clickable link, because you’ll have to edit it to add your login. So, for instance, if your name is Annette Czernikoff and your login is aczernik@calpoly.edu, you’d put aczernik in the login spot.