User:Quozl

Pippy Design Idea 2011-03-10

Usage

A learner will:

• review and run included examples,
• modify included examples, and run them,
• derive more complex code using included examples,
• derive more complex code using modules created by teachers or other learner, with or without changing the contributed module,
• write fresh modules.

A group of learners will do the above, but also:

• collaborate on a set of modules included in the shared activity instance,
• run modules locally on each laptop.

A pair of learners may:

• create one subordinate module each, and concentrate on it,
• create one master module that imports the two subordinate modules,
• write unit tests in each subordinate module and run them locally on each laptop,
• integrate by running the master module.

Purpose

• increase code sharing,
• increase relevance to Python users,
• increase portability of code written, beyond Pippy and Sugar,

Data

A running Pippy instance will contain the following data:

• zero or more modules (each module is a python zip bundle, not a sugar bundle),
• each module will include zero or more source files,
• each module will include a source file setup.py capable of creating the python zip bundle output, but unless the user has asked to edit the setup.py, it will not be shown, instead a default will be used, maintained by Pippy,

A shared Pippy will contain the same data as above on each laptop.

Input

Pippy may read from:

• a saved instance of Pippy, in the journal,
• a module (python zip bundle) in the journal, (which may have come from a teacher, another learner, or a server),
• example modules included with Pippy,

Output

Pippy may write to:

• a saved instance of Pippy, in the journal,
  • (activation of this journal entry: run the Pippy activity and present exactly what was visible at the time the saved instance was created)
• a module (python zip bundle) in the journal.
  • (activation of this journal entry: run the Pippy activity in an execution only mode that behaves in the same way as the "run" button, displaying a VTE (only if stdout is written to, or stdin is read from), and if not exiting immediately, without creating a journal entry,)

Display

Display will contain:

• toolbar,
• a series of tabs, one for each module, an add module button, and an open example module button,
• within each module, a series of tabs, one for __doc__ that is not editable, one for each source file that is editable, and an add file button,
• within each file, a syntax highlighting text edit widget.

(the series of tabs encapsulated in another series of tabs is potentially difficult for a learner to comprehend, but an alternative tree view is thought inappropriate because of the horizontal space consumed, and because use of a module should be constrained to the public API of the module).

Process

When run is pressed, display will contain:

• toolbar,
• stdout stdin vte, (only if stdout is written to, or stdin is read from),
• a stop button.

Changes

Partial list of changes to bring Pippy existing source to a state consistent with the design above:

• remove the examples widget from the main screen, provide it only as an "open an example bundle" function,
• remove the output window from the main screen, provide it only when a program is run, and only if the program generates stdout or reads from stdin,
• enlarge the program text entry widget to be nearly full screen,
• encapsulate the program text entry widget in tabs for files in a zip bundle,
• encapsulate the bundle in tabs for zip bundles loaded into pippy instance,
• on standard sugar save, save all zip bundles and files in a sugar journal entry,
• provide an export zip bundle button that creates a sugar journal entry of type zip bundle, for sharing,
• provide a way to import zip bundles from journal into the current pippy instance, using the object chooser,
• on execution of a bundle, allow access to all other currently loaded bundles via import, and access to system bundles via import,

Alternative

• create a new activity.

Existing Situation

Pippy provides example scripts written in Python, allows the learner to run them, edit them, and save them as a journal entry. See definition of the term script and discussion of modules.