Breakout Topics and Questions
-----------------------------
What the Project Scientist wants...

1. Command Interface 

   Background: the ALMA and EVLA SSR docs require us to provide
   interactive command-line interfaces (CLI) and optionally some
   graphical user interfaces (GUI) to the package.  We want to 
   get the look-and-feel right to let the user (of any level) process
   their data most efficiently.

   - What part(s) of other package interfaces should import for ours?
     (e.g. AIPS, Miriad, difmap, IDL, ?)

   - Is our basic CLI model right?  e.g.

        a) enter interface for tool/task
        b) query/set parameter values
        c) optionally get some help (see #4 below)
        d) execute task

   - Should the tool and task interfaces be the same?  See also #3 
     below...

   - How do we best accommodate users of differening expertise levels
     (novice, intermediate, expert) and needs (casual user, frequent
     user, heavy user)?  Do we need different look/feel and if so what
     should these be?

   - Does the CASApy interface previewed here and in the latest ALMA
     test look to be on the right track?  If not, what should we be 
     doing instead?  If so, what is right and what can we do better?

2. Graphical Interface

   - Some GUIs are necessary, e.g. 

     a) image/data display (viewer)
     b) data plotting (msplot, plotcal)
     c) graphical parameter setting (clean boxes/regions)
     d) data flagging (in viewer and msplot)

     Are the current tools for these on the right track?  What would
     the users like to see?  Are there better models out there?
     Should these be simple or have extensive functionality (e.g. viewer)?

   - Is there a role for GUI parameter setting (forms, tool managers)?
     Should the package provide a uniform GUI interface equivalent to
     the CLI?

   - Should we provide extensive capabilities for custom GUI
     development by the user or is Python enough?

   - What bits can or should be farmed off to standalone apps
     (e.g. the Miriad model)?

3. Tools and Tasks

   - Do we have the models and definitions right? e.g.

        "tool" - bottom (fine-grain) level of functionality, important
                 for scripting and tool/pipeline development.  In c++

        "task" - a more coarse-grained bundling of functionality akin 
                 to AIPS and Miriad tasks, used to carry out basic or
                 commonly used sequences of data processing operations
                 with "astronomical knowledge" built-in.  Most likely
                 in c++

        "procedure" - a Python script that runs a sequence of tool
                 and/or tasks.  Can be provided by project or user
                 developed.

   - What is the list of key tasks to work on first?  What level of
     combination is needed (e.g. imager+calibrater for selfcal)?

   - Is extensive feedback from tasks (e.g. return variables for
     pipelines) needed?

   - Do we have the inteface models right (see #1 above)?

   - Should the tasking model be more "data-centric" (e.g. you choose
     a dataset to work on up top and the tools/tasks follow)?

4. Documentation

   - What are the levels of documentation needed? e.g.

     a) quick tool/task info  (e.g. INP)
     b) more extensive info (e.g. HELP)
     c) detailed help (EXPLAIN)
     d) Cookbooks
     e) Getting started docs
     f) user programming docs
     g) detailed programmer docs

   - What (inline) help is needed at the CLI?

   - What should the (online) documentation contain?

   - Who needs to create and maintain what documentation?  (Note -
     there is currently no budget provided to the aips++/casa group
     that will allow extensive user documentation beyond basic
     interface info.)

   - Is there a role for consensual community documentation (e.g. wikipedia)?

X. Other comments on stuff like:

   - Distribution (is this working for people?)

   - Known Issues (existing stuff that doesnt work right that had
     better be fixed)

   - Existing Schedule/Plan (Query to Projets: is this schedule ok?)