GitHub
People
Publications
Calendar
Projects
Fall 2017
Older Courses
Spring 2017
Fall 2016
Spring 2016
Fall 2015
Spring 2015
Fall 2014
Spring 2014
Fall 2013
Spring 2013
Fall 2012
Spring 2012
Fall 2011
Spring 2011
Fall 2010
Spring 2010
Fall 2009
Spring 2009
Fall 2008
Spring 2008
Fall 2007
HOWTOs
edit SideBar

Home Assignments Lecture Blog Resources Project Discussion Group
Exam 1 is Mon Oct 20 Exam 2 is Mon Nov 17 Final is Wed Dec 17 at 8a
Echo360 lecture recordings are at http://echo360.uml.edu/martin201415/orgproglangfall.html
Whiteboard photos are at https://plus.google.com/u/0/114049637113235097633/posts/USJSUa6M4Vw
Final Exam Results 85 points were available. Mean was ~54. 73 students sat the exam.
Homework
Below is distribution of people's work on the problem sets. Max 1000.
Study notes for Final exam: Attach:oplbodyofknowledgefall2014.txt
Meeting 40, Wed Dec 10
 Project demos, part 2, in 3rd Floor Elevator Lobby
Meeting 39, Mon Dec 8
 Project demos, part 1, in 3rd Floor Elevator Lobby
Meeting 38, Fri Dec 5
About projects and presentations/demos
 please have your Project stubbed in by Sunday night
 all project web pages are due 8a Monday morning
 project demonstrations will be held in CS Dept 3rd Floor Elevator Lobby
 bring your laptop running your code to your presentation (if neither partner has a laptop—arrange to share one with a classmate)
 bring one printed copy of your web page to your demo
 prepare to present your project in about 3 minutes
 attendance at your presentation is mandatory
 attendance at demonstrations on the day you're not presenting is optional
About final exam
 there will be checkboxes to replace Exam 1 and/or Exam 2 scores with score on Final
 you may bring 3 sheets of doublesided handwritten notes to the final
 partial credit will be awarded on most if not all problems
 all Exam 1 and Exam 2 material, plus:
Today's material
 procedure application for compound procedures
let>combination
Course evaluations
Meeting 37, Wed Dec 3
Meeting 36, Mon Dec 1
Meeting 35, Mon Nov 24
Meeting 34, Fri Nov 21
Meeting 33, Wed Nov 19
 introducing streams (Section 3.5 of book)
 after class, PS8 was posted, due Wed 11/26
Meeting 32, Mon Nov 17
Meeting 31, Fri Nov 14
 Exam stuff
 PS5 and PS6 solutions will be mailed to newsgroup
 They are passwordprotected and the password will be given in lecture
 You are allowed one 8.5x11" page of handwritten notes (doublesided OK)
 OPL Final project proposal presentations
Meeting 30, Wed Nov 12
Exam 2 review:
 equivalence of
let and lambda ; that let is syntactic sugar for lambda (Section 1.3.2, “Using let to create local variables”)
 You should be able to translate from
let expressions to their equivalent lambda expressions
 and viceversa
 and for nested let's / lambda's.
 equality testing via
eq? (same object), eqv? (individual items having same value, tested with = for numbers or eq? for other things), and equal? (recursively testing structures using eqv? )
 numeric equality (
= operator) is defined as: “An inexact number is numerically equal to an exact number when the exact coercion of the inexact number is the exact number. Also, 0.0 and 0.0 are numerically equal, but +nan.0 is not numerically equal to itself.” http://docs.racketlang.org/reference/genericnumbers.html#%28def._%28%28quote._~23~25kernel%29._~3d%29%29
 symbols are
eq? to themselves; i.e., (eq? 'foo 'foo) is #t .
 there is only one empty list; i.e.,
(eq? '() '()) is #t .
 given various objects, you should be able to say whether they are
eq? , eqv? , and/or equal? to each other.
 the symbolic differentiation problem set—how it works
 the type systems problem set—how it works
Meeting 29, Mon Nov 10
Meeting 28, Fri Nov 7
 discussion of simpleoo code
 super brief into to adventure game PS
Meeting 27, Wed Nov 5
 Exam 1 handed back; average was ~22. Results are compressed at the high end—max score was 36, but 6 extra credit points were available
 went over fold problem
 continuing discussion of environments/frames, procedure creation, and closures
Meeting 26, Mon Nov 3
Meeting 25, Fri Oct 31
 “Type Systems  The Good, Bad and Ugly” by Paul Snively and Amanda Laucher
Meeting 24, Wed Oct 29 Continuing discussion of type systems.
 book discusses three ways of organizing type systems:
 generic operations with explicit dispatch,
 datadirected (the
applygeneric system we're using), and
 messagepassing.

Explicit dispatch 

Datadirected 

Messagepassing 
 Type coercion — Section 2.5.2, “Combining Data of Different Types”
 Let's understand Ex. 2.81, about type coercion (
p5.rkt ).
Important note: You have to copy in the new version of the applygeneric procedure, and create global bindings (define putcoercion put) and (define getcoercion get) .
Meeting 23, Mon Oct 27
Continuing discussion of type systems.
 Let's understand Ex. 2.77, about adding complex number selectors to the complex number type (problem p2 in the PS).
 Let's understand Ex. 2.78, about updating
schemenumber to use Scheme's underlying numerics (problem p3 in the PS).
 Let's understand Ex. 2.79, about defining an equality predicate (problem p4 in the PS).
Meeting 22, Fri Oct 24
 Section 2.4 of text, “Multiple Representations for Abstract Data”
 adding and multiplying complex numbers—use rectangular form for add/subtract; polar form for multiply/divide
Meeting 21, Wed Oct 22
Meeting 20, Mon Oct 20
Meeting 19, Fri Oct 17
 about FPE1—see my newsgroup post and discussion in class of sample work
deepreverse
bluessale
 PS4 and anything else for exam
Meeting 18, Wed Oct 15
 PS2 PS3 PS4 answers presented
Meeting 17, Fri Oct 10
Meeting 16, Wed Oct 8
Meeting 15, Mon Oct 6
 bucket  operation changes depending on what the operand is  see solution at 19:00 mark of the lecture recording.
 flip functions and function composition
 cdDB  restock and others
Meeting 14, Fri Oct 3
(load "fredsdb.rkt")
(map title cdDB)
(titlesinstock cdDB)
(titlesby "The Beatles" cdDB)
(copiesinstock "Revolver" "The Beatles" cdDB)
(set! cdDB (restock "Revolver" 10 cdDB))
(copiesinstock "Revolver" "The Beatles" cdDB)
(carrycd? "The White Album" "The Beatles" cdDB)
(carrycd? "Help!" "The Beatles" cdDB)
(bluessale cdDB)
accumulate , foldr , and reduce are synonyms
 they take a list, a binary operator, and an initial value and pairwise apply the binary op to the head of the list and the recursive result
 let's look at
foldl
 some things you can do with accumulation/reduction/folding
 sum up the numbers in a list
 make a product of all #s in a list
 summarize all of the even numbers in a list
 rebuild a list in new ways (using
cons as the binary op)
treemanip is like a tree version of fold
Meeting 13, Wed Oct 1
 data abstraction, constructors and selectors
“Data abstraction is a methodology that enables us to isolate how a compound data object is used from the details of how it is constructed from more primitive data objects.”
 do not violate the abstraction barrier —
 in other words, use selectors to pick apart compound objects and constructors to build them back up again
cons , list and the like should only be in constructors
car , cadr etc. should only be in selectors
first is a synonym for car , second for cadr , etc.
 point and line abstractions; midpoint function
 building point objects using lambdas/messagepassing
 look at CDDB problem in PS
Meeting 12, Mon Sep 29
Meeting 11, Fri Sep 26
let is lambda , and closures
Meeting 10, Wed Sep 24
 three
cons /list , printed form, and boxandpointer test items
 recap of recursion: base case, recursive case, invariants
 recap of
append
map filter accumulate
 lambda and closures and let
Meeting 9, Mon Sep 22
 PS3a extended until Friday
 we left off with
scalelist
 let's look at properties of recursion:
 base case
 recursive case
 invariants — what's always true
 state variable(s) (with iterative recursions)
length  recursive and iterative
last
append
Meeting 8, Fri Sep 19
 introducing our 2nd TA: Peng Hou. Office hours: Mon 2p to 3:30p.
 TAs are grading PS2 now
 please give yourself more than one session to complete homework
 please try your best to solve problems before looking up answers
 recursive and iterative
sumnat (simulated test problems)
 list primitives:
cons , car , cdr , list , and null?
 What is
(cons 1 (list 2 3 4)) versus (cons (list 1 2 3) 4) ?
sumlist
scalelist
Meeting 7, Wed Sep 17
 Fred's office hours: W 2p in Olsen 208, R 2p in Olney 524, F 1p in Olsen 308 (1 hr each). Please confirm before coming if possible.
 issues with PS2?
 let's do exercise 1.11 together
 lists 
cons , car , and cdr
 making a list with
list
 summing up a list
 scaling a list
 Assignment 3 is posted; due next Weds https://grader.cs.uml.edu/assignments/385
Meeting 6, Mon Sep 15
 two versions of
expt
 what is tail recursion?
“One reason that the distinction between process and procedure may be confusing is that most implementations of common languages (including Ada, Pascal, and C) are designed in such a way that the interpretation of any recursive procedure consumes an amount of memory that grows with the number of procedure calls, even when the process described is, in principle, iterative. As a consequence, these languages can describe iterative processes only by resorting to specialpurpose ‘looping constructs’ such as do , repeat , until , for , and while . The implementation of Scheme we shall consider in chapter 5 does not share this defect. It will execute an iterative process in constant space, even if the iterative process is described by a recursive procedure. An implementation with this property is called tailrecursive. With a tailrecursive implementation, iteration can be expressed using the ordinary procedure call mechanism, so that special iteration constructs are useful only as syntactic sugar. ”
 which
expt is tailrecursive?
sumintegers and sumcubes
 let's abstract that
Meeting 5, Fri Sep 12
 polls on evaluation questions (these are sample test questions)
 let's look at Eric's recursive square example:
(define (squarer n)
(cond ((= n 0) 0)
((= n 1) 1)
(else (+ (squarer ( n 1))
n
( n 1)))))
Does it generate a recursive process?
 Rewrite it to generate an iterative process.
 passing functions to functions
Meeting 4, Wed Sep 10
 Exam 1 is Mon Oct 20; Exam 2 is Mon Nov 17
 more on iterative vs. recursive processes and substitution model
 reviewing substitution model for two versions of factorial
 exercise 1.9 in class
 demo of Racket development and testing bestpractices
 go over PS1 (volunteers?)
 PS2 Iteration vs. Recursion and Higher Order Procedures assigned, due Wed 9/15
Meeting 3, Mon Sep 8
 fire alarm
 TA: YenFu ("Edward") Luo,
edwardluoopl@gmail.com . Office hours: Tue/Thu 12:30p – 2:00p.
 what is a predicate?
Definition: “A procedure (or function) that returns true or false.”
by convention, the name of a predicate ends with a questionmark — e.g., even? , odd? , symbol?
 numeric predicates:
= , < , >
 how to use
cond
cond is syntactic sugar for nested if 's
(define (die n)
(cond ( (= (remainder n 3) 1) 'a )
( (= (remainder n 3) 2) 'wizardtype )
(else 'sorryyouredead)))
and and or exist, and have special evaluation rules (they shortcircuit)
AND shortcircuit [no longer evaluates the remaining] as soon as it encounters a false, and OR as soon as it finds one that's true.
not inverts boolean value. Normal evaluation rules apply. Even though it's a procedure that produces a true/false output, it's not considered a predicate because it's not answering a question about its input.
 discussion of symbols—
 naming is done all lowercase with dashes as word separators
symbol? tests if a thing is a symbol
 symbols are fundamental objects, like numbers and procedures and booleans
 procedures can return symbols
 more on iterative vs. recursive processes
 reviewing substitution model for two versions of factorial
 PS1 Introduction to Scheme is due Wed 9/8
Meeting 2, Fri Sep 5
 introducing our TA: YenFu Luo !
 use group for discussion — presently, 62/81 have joined
 Bottlenose — you must proactively request account — 60/81 are onboard
 class policies
 Scheme numbers — exact (ints, rats, arbitrarily large ints) and inexact (floats)
 returning to expressions —
(= 3 3) , (define foo 3) , (lambda (n) (* n n)
if expr — often used w/o side effects, meaning, it returns a value and doesn't “do stuff”
 our first recursion: factorial (recursive process)
 our second recursion: factorial (iterative process)
 PS1 Introduction to Scheme due Wednesday
What is the value of (lambda (n) (* n n)) ?
What is the value of (define foo 3) ?
Meeting 1, Wed Sep 3
 what is OPL (discussion)?
 introduction to Scheme
 everything is an expression
 some basic data types: numbers, symbols, booleans (there are also strings)
(+ 3 4) means apply the + procedure to params 3 and 4
+ is a procedure
 we can bind stuff to symbols, e.g.
(define foo 3)
 we can make procedures, e.g.
(lambda (n) (+ n 1)) increments its arg
 we can create a procedure and immediately apply it, e.g.
((lambda (n) (+ n 1)) 3) is 4
 we can name procedures by binding symbols to them, e.g.
(define inc (lambda (n) (+ n 1))
if is an expression; e.g. (if #f 3 4) is 4
 notes from lecture:
Evaluation rules of scheme:
evaluate the first thing, apply to the values of the rest of them.
exceptions:
DEFINE take the second thing as the name of a symbol, and bind it to the
value of the third thing.
LAMBDA  take a list of params and an expression, and create a procedure
object with these two things.

ENVIRONMENT  place where symbols are bound to objects
TYPES OF OBJECTS:
func/procedures
datatypes  numbers, bools
