<aside> ⚠️ Didn’t include notes for the following videos as much of them was already covered in How to Code:

• Racket Definitions, Functions, Conditionals (Lambdas, if expressions, currying)
• Racket Lists (using the list keyword to build lists)
• Syntax and Parentheses
• Parentheses Matter! (Debugging Practice)
• cond (multi-pronged conditionals) </aside>

Dynamic Typing

• In dynamic typing,
  • The types of variables in the program aren’t checked before the program runs, so type errors can only be caught at runtime.
  • Since errors can only be caught at runtime, mistakes in lines of the program that are not run will not throw exceptions.
  • Type checkers don’t exist, so values of any type can be used anywhere (e.g. values in a list don’t have to be of the same type).

Local Bindings

• Racket has 4 different keywords for different kinds of local bindings:
  • let
  • let*
  • letrec
  • define

Toplevel Bindings

• In Racket, all bindings in a program are within the same environment.

  • This is different from ML. In ML, the current environment at any binding consists of the binding in question along with the bindings defined before it.
  • This is because Racket programs are implicitly in their own modules.
    • Its top-level bindings aren’t really ‘top-level’ bindings formally.
    • Each module (program) can shadow bindings from other modules (programs) imported into it.

• As such,

  • In Racket, you can use bindings before or after they are defined.
    • Similar to local defines and letrecs.
  • In ML, you can only use bindings after they are defined.