Lectures

Note that pages might change, even just before or just after a lecture. The lecture notes are intended as an aid, but are no replacement for attending class.

When discussing grammars, here is the google-doc we worked through in class:
Section 01; Section 11.

Also, here is a file ../../../../Teaching/ITEC380/2015fall-ibarland/Lectures/student-extras.rkt, which contains an extra helper function or two, along with some language features from full racket in a way that can still be used with the student-level languages.

Helpful Links

Other resources on learning racket/scheme. Please comment on the discussion boards, about how helpful you do (or don't) find these, so that I can recommend them more/less highly to others.
a Racket Style Guide (sections 4 and 5 are pertinent for learners).
Adding type-checking: If you want (run-time) type-checking in your Racket programs, see contract-examples.rkt.
Understanding quote and backquote.

Distance lectures

Note that the distance-section lectures can diverge from the in-class lectures, based on questions people ask, etc.. These recordings are not a substitute for students in the in-class lectures. However, they're posted, because why not?

dec-01 part3 (1h:00m): let-over-lambda
dec-01 part2 (0h:53m): finish prolog list; prolog sort.
dec-01 part1 (0h:59m): prolog lists

nov-17 part3 (0h:56m): prolog: cousin; list-intro.
nov-17 part2 (0h:53m): prolog, cont.
nov-17 part1 (1h:00m): review P2 hw req'ts; start prolog

nov-10 part3 (0h:45m): The Law of Racket 10min Prolog teaser
nov-10 part2 (0h:54m): test case framework (incl. for `substitute`)
nov-10 part1 (0h:51m): Review P0, P2 tests

nov-03 part2, part3 (1h:56m): Discuss lambda on hw06.
Look at P0, and representation in racket-structs.
Look at AncTree in Java, and how to represent union-types via an abstract class w/ 1 subclass per variant.
(5min break here?)
Objects that happen to print as legal program-expression.
P0 code for eval and toString
Look at P0, and representation in java-structs
Code for parse (racket)
nov-03 part1 (0h:55m): discuss exam-soln; look at P0 grammar and derive example programs in P0.

oct-20 part3 (0h:50m): Signature for filter and map; how to (fake) passing code in pre-Java8, and also how it looks in Java8. See lect29-dist.rkt (but just the first half, up to the Java-code parts), and then lect22-passing-functions.rkt (last two-thirds, or so.)
oct-20 part2 (0h:55m): Using filter (and map); writing them. Glimpse of one other higher-order function (`compose`). See lect28-dist.rkt.
oct-20 part1 (1h:05m): Writing functions for anc-tree. See lect27-dist-ancestor-tree.rkt (second half).

oct-20 part3 (0h:55m): finish tail-recursion; data-defn for anc-tree. See lect27-dist.rkt.
oct-20 part2 (0h:54m): lambda as an adaptor; filter; mention fold. See lect26-dist.rkt.
oct-20 part1 (0h:27m): hw05a soln; map; lambda. (First half not recorded.) See lect25-dist.rkt.

oct-13 part3 (0h:50m): `let*`, scope, and binding (free vs bound) See lect24-dist.rkt.
oct-13 part2 (0h:50m): natNums (data-def'n; programs using it) See lect23-dist.rkt.
oct-13 part1 (1h:02m): hw review; `my-max`, and `let` (exactly what local variables give us). See lect22-dist.rkt.

oct-06 part3 (1h:02m): Lists: triple-every-even; using the stepper; `my-max` and mentioning `let*`.
oct-06 part2 (1h:00m): Lists: repeat `sum`, `length`, `contains-93`, application of template.
oct-06 part1 (0h:57m):

sep-29 part3 (1h:10m): lists, continued: `length`, `contains-93` all by the template. Dropped audio at the end.
sep-29 part2 (0h:45m): list intro; `sum` by the template. Dropped audio, grrr.
sep-29 part1 (1h:02m): finish grammars; introduce lists.

sep-22 part3 (1h:01m): recursive rules in grammar; see also google doc pad
sep-22 part2 (0h:58m): grammar rules
sep-22 part1 (0h:56m): hw03 discuss.

sep-15 part3 (1h:20m): structs containing structs; structs containing unions. (Last 15min is after-class discussion on hw.)
sep-15 part2 (0h:39m): functions returning structs; unions containing structs
sep-15 part1 (1h:29m): hw02 discuss.

sep-08 part3 (0h:44m): struct practice; some vocabulary
sep-08 part2 (0h:43m): define-struct
sep-08 part1 (1h:08m): hw discuss; more union types w/ cond.

sep-01 part3 (0h:45m): language families
sep-01 part2 (1h:35m): continue function defn and tests; `cond`.
sep-01 part1 (0h:58m): defining functions; `check-expect`; design recipe

aug-25 part3 (1h:50m): racket intro: types; calling functions; nesting expressions (top-down vs bottom-up)
aug-25 part2 (0h:35m): continue: how language-choice influences how you choose to solve your problem: arrays vs lists vs hash-tables example.
aug-25 part1 (1h:01m): intro; why study langs? How language-choice effects how you choose to solve your problem: example: arithmetic.

Much appreciated: If you have any improved description or info, please send it to me and I'll add it to this page. E.g.:

“dec24 part2 has dropped audio from 0h:50m-0h:55m”
“dec24 part1 is mostly about parsing, not an intro-to-grammars.”
“dec24 part3 is really only 0h:50m long; there is just 20m of silence at the end.”
“sep15 dist-week03a: for the first half, he says ‘card-rank’ when he really means ‘c-rank’ — possibly confusing since card-rank is an accessor, not a type.”

You can also access recordings from a previous semester.

most recent semester

©2015, Ian Barland, Radford University
Last modified 2015.Aug.30 (Sun) Please mail any suggestions
(incl. typos, broken links)
to ibarlandradford.edu