These are the class notes files. In some places they are in pretty raw form, intended mainly for reference, code examples etc. They are not a substitute for taking notes in class, and they certainly cannot compensate for not coming in. Also, they are not guaranteed to cover all of the material that was presented in class.
| • Lecture #1 Wednesday, January 9th |
Introduction to Programming Languages (CS4400/CS5400) |
| • Lecture #2 Friday, January 11th |
Introduction to Racket Quick Introduction to Racket Lists & Recursion Some Style |
| • Lecture #3 Wednesday, January 16th |
Names are Important Note on Types BNF, Grammars, the Simple AE Language Simple Parsing The ‘match’ Form Semantics (= Evaluation) Implementing an Evaluator Implementing The AE Language Introduction to Typed Racket |
| • Lecture #4 Friday, January 18th |
Bindings & Substitution Adding Bindings to AE: The WAE Language Implementing ‘with’ Evaluation Formal Specs Lazy vs Eager Evaluation de Bruijn Indexes |
| • Lecture #5 Wednesday, January 23rd |
Functions & First Class Function Values Implementing First Class Function Values The FLANG Language |
| • Lecture #6 Friday, January 25th |
Introducing Racket’s ‘lambda’ Using Functions as Objects Currying Using Higher-Order & Anonymous Functions: "Point-Free"/Combinators Substitution Caches Initial Implementation of Cache Functionality Formal Rules for Cached Substitutions Evaluating with Substitution Caches |
| • Lecture #7 Wednesday, January 30th |
Dynamic and Lexical Scopes Dynamic versus Lexical Scope Implementing Lexical Scope: Closures and Environments |
| • Lecture #8 Friday, February 1st |
Implementing Lexical Scope: Closures and Environments (contd.) Fixing a Bug Implementing Lexical Scope using Racket Closures and Environments More Closures (on both levels) Types of Evaluators Feature Embedding |
| • Lecture #9 Wednesday, February 6th |
Recursion, Recursion, Recursion Recursion without the Magic The Core of ‘make-recursive’ |
| • Lecture #10 Friday, February 8th |
A More Methodical Explanation of Recursion The Y Combinator Typing the Y Combinator |
| • Lecture #11 Wednesday, February 13th |
Lambda Calculus – Schlac Church Numerals More Encodings Alternative Church Encoding |
| • Lecture #12 Friday, February 15th |
Recursive Environments Recursion: Racket’s ‘letrec’ Implementing Recursion using ‘letrec’ |
| • Lecture #13 Wednesday, February 20th |
Midterm review |
| • Lecture #14 Friday, February 22nd |
Implementing ‘rec’ Using a Cyclic Structure Boxes and Mutation Types for Boxes ‘Boxof’s Lack of Subtyping Implementing a Circular Environment |
| • Lecture #15 Wednesday, February 27th |
Variable Mutation State and Environments Implementing Objects with State The Toy Language "Compilation" and Partial Evaluation |
| • Lecture #16 Friday, March 1st |
"Compilation" and Partial Evaluation (contd.) Lazy Evaluation: Using a Lazy Racket Lazy Evaluation: Some Issues |
| • Lecture #17 Wednesday, March 13th |
Lazy Evaluation: Shell Examples Lazy Evaluation: Programming Examples Side Note: Similarity with Generators and Channels Call by Need vs Call by Name Example of Feature Embedding Implementing Laziness (in plain Racket) Sloth: A Lazy Evaluator |
| • Lecture #18 Friday, March 15th |
Implementing Call by Need Side Effects in a Lazy Language Designing Domain Specific Languages (DSLs) |
| • Lecture #19 Wednesday, March 20th |
— |
| • Lecture #20 Friday, March 22nd |
Syntax Transformations: Macros Macro Problems Scheme (and Racket) Macros Using Lazy Constructions in an Eager Language Recursive Macros |
| • Lecture #21 Wednesday, March 27th |
Recursive Macros (contd.) Problems of ‘syntax-rules’ Macros Racket’s "Low-Level" Macros Macro Conclusions |
| • Lecture #22 Friday, March 29th |
Types What is a Type? What are Our Types – The Picky Language Typing control |
| • Lecture #23 Wednesday, April 3rd |
Implementing Picky |
| • Lecture #24 Friday, April 5th |
Implementing Picky (contd.) Typing Recursion Typing Data Type soundness |
| • Lecture #25 Wednesday, April 10th |
Explicit polymorphism Web Programming Introduction to Continuations: Web Programming |
| • Lecture #26 Friday, April 12th |
More Web Transformations Highlevel Overview on Continuations Implementing an Automatic Continuation Converter |
| • Lecture #27 Wednesday, April 17th |
Continuations as a Language Feature Continuations in Racket Playing with Continuations Continuation Conclusions |
We will use the Racket environment extensively. DrRacket, the major component of Racket, will be used to develop code, debug, and submit homeworks. CCS computers have an updated version installed (available on both Unix and Windows). To use it on your own machine, get it from the Racket website. Binary installers exist for all major operating systems, and the course work will be platform independent.
Racket has a system for distributing software bundles that will be used to get a course-specific plugin. This packages both specific functionality for each homework, and an integrated tool for homework submissions. Once you have Racket installed, download the plugin package, and use the “Setup PLT” application to install it. You can also use “Install .plt File” in the File menu, and enter the URL for the plugin.
Note: The handin server uses a dedicated port for communication. You need to work from a network that does not restrict this port — for example, if you use Northeastern’s ‘NUwave-guest’ network, then you will not be able to connect to the server. ‘NUwave’ (which requires you to authenticate through myNEU) does not have this restriction.
To set-up your account:
Additional software may be used later in the course.
There is a piazza group for this course at Piazza.com. The piazza group is the main medium for discussions, questions, announcements etc. You should use it if you have any questions, so others can benefit from the discussion as well. If you want to ask a question that involves showing your solution code, make sure that you choose the “private” option. Do not to post any homework code on the piazza group without using the “private” option. Direct emails to the course staff should be your last resort. Consult the Email and Piazza Group Policies handout for further details about piazza group posts and emails.
Note that you do not need to request to be subscribed to the mailing list — you will get added after you register with the submission server.
IRC, or “Internet Relay Chat” is a text-based chat protocol where people can join channels on IRC servers and communicate. IRC is sometimes refered to as “interactive notepad”. The major benefit of using IRC is real-time conversations with fellow class members as well as course staff.
If you have a CCIS account, you are almost ready to start using IRC. The following will describe a basic configuration, as described by jmendel (aka John Mendelewski). Feel free to set up your client as you wish.
ssh 〈CCIS-username〉@〈machine〉.ccs.neu.edu |
screen |
irssi |
/connect irc |
/msg nickserv register 〈some-password〉 |
/msg nickserv identify 〈some-password〉 |
/join #pl /join #pl-talk |
screen -rd |
Finally, IRC is a valuable resource: don’t abuse it! Specifically, you should not post any source code, and you should try to read homework texts thoroughly before you ask questions. This applies for both channels.
There are lots of Racket and Scheme books on-line, a few good ones are: