CS 330: Final

See the PDF.

CS 330: Lecture 39 – Exit(0)

Dear students, Today we close out our formal exploration of the stuff of programming languages. This is what we said we’d look into in the syllabus: Recognize and exploit the strengths of three major programming paradigms: imperative, functional, and object-oriented. Reason about the strengths and weaknesses of various type systems. Weigh the costs and benefits […]

CS 330: Lecture 38 – Automatic Test Running Via Metaprogramming

Dear students, Last time we saw how we could add a hook in Ruby so that when a non-existent method is called on a object, we can still execute the desired action. method_missing lets us write really virtual methods—ones that don’t even exist. Our code effectively used information about the method that would have been […]

CS 330: Lecture 37 – Object-relational Mapping Via Metaprogramming

Dear students, Metaprogramming is our theme for this last week of the semester. What is metaprogramming? It’s when code generates code. It’s when user input is used to generate new classes, methods, and so on. You’ll probably all felt at certain points that the code you are writing probably didn’t need to be written by […]

CS 330: Lecture 36 – Taming Recursion

Dear students, We’ve seen that Haskell does some pretty crazy things: it infers types, it supports this crazy pattern matching stuff, it disallows side effects, and it computes things lazily. Let’s look at one last crazy thing it does: it uses recursion for everything! There are no loop control structures. Normally, when you think of […]

CS 330: Lecture 35 – Call-by-need

Dear students, Last time we introduced a different way of passing parameters. Instead of eagerly evaluating them, we delayed evaluation until they were referenced inside the function. We looked at two examples of delaying evaluation: C preprocessor macros and writing our own control structures. I want to discuss the first of these a little bit […]

CS 330: Lecture 34 – Call-by-name

Dear students, When you call a function, what happens? In particular, what happens in this code? int m() { cout << "m" << std::endl; return 5; } int r() { cout << "r" << std::endl; return 7; } int multiply(int a, int b) { cout << "*" << std::endl; return a * b; } int […]

CS 330: Lecture 33 – Closures Continued

Dear students, Last time we ended in the middle of a discussion about the dangers of closures oversharing values. We fixed the situation by adding a function to introduce a new scope for each closure so they wouldn’t clobber each others’ state. This situation happens frequently enough in Javascript that there’s a slightly simpler idiom […]

CS 330: Lecture 32 – Closures

Dear students, Let’s start with a Program This! Consider the foreach algorithm: for each item in list do something with that item (call a method, print, etc.) The core idea is that we have a list of items, and we want to produce some side effect for each of them. The foreach algorithm doesn’t return […]

CS 330: Lecture 31 – HOFs and Lambdas in Java

Dear students, Is Haskell the only language that supports composition and higher-order functions? No. Does Java? It can be made to! Let’s do that today. We start by porting the . operator. What do you suppose the type signature of . is in Haskell? Well, it takes in two functions and gives back a new […]

1 2 3 35