Group A notes, Thu, 5/29

decided to produce a list of behaviorial objectives

discussed how to get good teaching evals
Lynn: student may not know until years later; need to do something that seems
connected to what interests them
Mark: more of a how question

Doug: synthesize or analyze (build x or analyze x)

We went back to the main room to come up with proposed behavior objectives,
then went around giving objectives:

John:
specify precisely and implement correctly a small PL (domain-specific)
formalize: grammar, type, semantics
1) implement given spec
2) write languuage spec

Kim:
Write program(s) in multiple paradigms and evaluate strength/weakness of each
paradigm
Lynn: Given problem, choose appropriate language and/or abstractions, to
explain why choice is appropriate, and to articulate tradeoffs.

Dan:
apply behavior-preserving transformations (e.g., continuation-passing-style,
a-normal)

Mark:
Able to learn new languages quickly

Lynn:
Write a program-manipulating program (interpreter, type checker, parser, etc)

Doug:
Emulate x in y, if possible, where x, y  are language/features (e.g., lazy
evaluation, continuations, closures, marcros, transations) and evaluate cost
and *-ilities (modularity, ...)

Stuart:
Explain at a high level the major differences between programming languages
including paradigm(s), properties of the type system, and binding mechanisms.

William:
Use reflection to write programs that analyze other programs/itself (e.g., test
case generator)

William:
Facility with advanced programming techniques:
    -state/mutability
    -modules/information hiding
    -continuations
    -higher order functions
    -exceptions
    -trampolines/dispatch
    -lazy evaluation/streams
    -transaction
    -parallelism/concurrency
    -reflection
    -polymorphism

hiearchy of:
    use
    emulate
    implement
    semantics
    analyze
    prove

paradigms:
    OO
    procedural
    functional
    concurrency
        shared variable
        message passing
        event based
    logic/constraint?

John:
formal specification:
    hoare logic
    write and prove correctness of simple program like binary search

after break, we decided to prioritize

dicothomy between:
    advanced programming techniques
    programs as data

Classification into:
    a) everyone should know
    b) end of PL course
    c) entry into grad PL course

Then talked about classifying the techniques as use vs deeper understanding
where a = use and m = (emulate/implement/semantics/analyze/prove)
    a    m      topic
    ---------------------------------------------------------
    a           -state/mutability
    a           -modules/information hiding
    ?           -continuations
    a           -higher order functions
    a           -exceptions
    a           -tail-call (emulate = trampolines/dispatch)
    ?           -lazy evaluation/streams
    a           -transactions
    a           -parallelism/concurrency
    a           -generics
    ?           -macros
    a           -method dispatch (dynamic binding)
    ?           -reflection
    ?           -type rules
    a           -subtyping
Then we abandoned the idea of the "m" column.

Then we went to identify "a" level topics from the earlier list:

Explain at a high level the major differences between programming languages
including paradigm(s), properties of the type system, and binding mechanisms.

Write program(s) in multiple paradigms and evaluate strength/weakness of each
paradigm

Ability to learn new languages quickly