$Id: mini-milestones.extended.txt,v 1.2 2002/04/08 18:49:58 yasuhara Exp $ 

last updated based on mtg. w/ Mary Cook on Tue 25 Mar 2002

open questions, misc. notes:

  * What were the milestones in the LEGO robotics project?

  * How should groups be formed, e.g., students w/ similar experience
    level together?

  * Instructor must make reasonable expectations explicit to reduce
    anxiety, comptetitive pressure for students w/ less background.

  * Consider allowing students who meet milestones early to help other
    students.

  * StarLogo: What file I/O facilities in standard library?
  
programming implementation notes:

  * API permits 90 degree turns, exposes turtle heading
  
course parameters (ENGR 100, Section D, 2002 Spring):

  * 8 PCs in classroom, ~8 laptops

  * 8 teams of 4 students

  * included in typical set of deliverables: lab checklists,
    write-ups, early draft of project report

  * project duration:  13 May through 07 Jun


[What is this again?  Keep in mind while developing lesson plans?]
duration: 
checkpoints/deliverables:
(room for creativity, open-endedness)


1.  programming & procedures 

opener:
  model of computer as instruction-following device
    programming as instruction-writing
    programming & relationship to computer science
  describe problem
    put into understood context:  robot control, agent-based web search
  project conclusion 
  skills
  StarLogo env't introduction
  other StarLogo apps
skills:
  basics of the StarLogo environment
  API procedures for movement, sensing  
concepts:
  procedures (non-parameterized)
    save and replay named sequence of commands
    e.g., forward-to-junction
activities:
  exploring interface
  manual control of turtle through maze (single-step procs.)
  solve maze w/ sequence of procedure calls
    encapsulated as proc. "solve-maze"
  (provide mazes motivate toolbox procs.)
closer:  
  run solve-maze on own maze
  then one team's on another maze to see failure (postpone to 3?)
  plan for remainder of project; estimated schedule

2.  making decisions:  control flow

opener:
  brainstorm toolbox procs. based on last session's mazes (e.g., TPS)
  make w/ list of procs.
  preconds, postconds, other assumptions about each proc.       
  basics of control flow
activities:
  write "forward-to-junction", turn to abs. heading
  if more time, write others 
deliverable:
  procs. 
  write-up of assumptions
closer:
  all together, run procs. to solve maze 

3.  making procedures flexible w/ parameters

opener:
  real-life instruction-giving w/ parameters, e.g., computing formulas
  StarLogo parameterization syntax
activities:
  identify useful parameterization StarLogo maze-solving
  write parameterized procs., e.g., those from last session
deliverables:
  own real-life examples of parameterized instructions 
  procs. 
closer:
  as for last session
  run one team's solving on another maze to see failure

4.  algorithms

opener:
  algorithm, communicating problem-solving strategy to people, to computers
  what algorithms are, why important
  independent of implementation
  procedure as means of expressing algorithm in computer-readable form
    alg. written for other humans
      leverages flexible model of interpretation
    when implementing, use precise language
  real-world examples, real-life maze solving
concepts:
  alg. vs. proc., pseudocode vs. code
activities:
  acting out algorithms [three words:  red cube costume]
    mazes taped out on floor
    students write algs.
    instructor acts out alg. execution
    (might need props for randomization)
  create mazes good, bad for given algorithm    
    identifying assumptions in algorithms (provide initial mazes to ground)
  provide a few more API tools, e.g., marking where you've been
  start designing algs. (but not implementing)
deliverable:
  written algorithm description
  good, bad mazes; mazes useful for testing

5.  work period

opener:
  check-offs on written alg. descr.
  StarLogo patch editor for creating mazes [must be moved earlier]
activity:
  alg. implementation & maze creation (realizing test cases)
closer/deliverables:
  produce at least one maze
  run alg. on at least one maze
  docs on more API, e.g., marking where you've been

6.  work period

closer:
  show off algs. on own maze(s), then other teams' maze(s)
  intro of more API covered in docs provided last session

7.  data structures

opener:
  lists, queue/stack in one, priority queue
    all for storing past turtle coordinates, heading
  example uses to illustrate each d.s.?
  intro. breadth-first search (maybe replaced by activity)
activity:
  group exercise to discuss how to leveraging d.s., backtracking
  updating, creating mazes for testing, challenging 

7'.  maze generation

10.  demo/competition?

activities:
  demos
final deliverables:  
  assessment of alg.:  
    strengths/weaknesses
    good/bad mazes
  algorithm comparison lab report, formatted as for
    experimental science (e.g., chem, physics) 
  if algorithm was updated, updated written description