Pigeon Computer 0.1 Initial (BETA) release

Simon Forman forman.simon at gmail.com
Sat Dec 22 00:21:06 CET 2012 

Pigeon Computer 0.1 Initial (BETA) release

Summary
============

The Pigeon Computer is a simple but sophisticated system for learning
and exploring the fundamentals of computers and programming.

It is written to support a course or class (as yet pending) to learn
programming from the bit to the compiler.

There is a DRAFT manual and a Pigeon User Interface that includes:

  * An assembler for the ATmega328P micro-controller.
  * A polymorphic meta-compiler.
  * Forth-like firmware in assembly.
  * Simple high-level language for assembly control structures.
  * A virtual computer that illustrates Functional Programming.

Source code is released under the GPL (v3) and is hosted on Github:
  https://github.com/PhoenixBureau/PigeonComputer

The manual is online in HTML form here:
  http://phoenixbureau.github.com/PigeonComputer/

Mailing list:
  https://groups.google.com/d/forum/pigeoncomputer

It has been tested on Linux with Python 2.7, YMMV.

I'm releasing it now because it's basically done even though it needs
polish and I'm just too excited about it.  Happy End of the World Day!


Details
============

The class starts with "the bit" and develops the core concepts
underlying computers with a hands-on exploration of bits and bytes as
embodied in physical "bits" on a table: coins or other binary
"tokens".

Using this "RAM-abacus" we explore different coding schemes (binary
numbers, ASCII codes, Grey codes, etc.) and then play with simple
operations to show how the bits can be used to perform math and logic
as well as simple "text processing".  We number the operations, lay in
simple "programs" in the "RAM", and manually act out the actions of a
(hypothetical) CPU.

Once the students have the idea we introduce a concrete example: the
ATmega328P, a simple but powerful 8-bit RISC micro-controller with
Harvard Architecture and a 16-bit program RAM that is used in many
popular devices such as the Arduino Uno.

Using this chip and the Pigeon User Interface students will be able to
develop simple robots and other devices and program them themselves.

 - - -

The Pigeon User Interface (PUI) is a simple and elegant IDE that
presents the user with a very simple but powerful stack-based virtual
computer that includes commands for assembling object code for the
ATmega328P and compiling high-level languages to assembly.

To get the students into assembly language the Pigeon Computer system
includes a tiny Forth-like firmware that implements a command
interpreter on the serial port (on-chip USART peripheral) in less than
a kilobyte of object code.

The firmware is a stub. It is meant to be understood and extended by
the students rather than used as-is.  I have written some commands for
it that give it the ability to use the TWI (I2C) subsystem of the
ATmega328P to communicate with other devices, and used that to talk to
an Inertial Motion Unit and get gyro and accelerometer readings, so
there's that.

Once students are comfortable with assembly, the PUI includes a tiny,
powerful, and extremely flexible meta-compiler: Val Shorre's Meta-II
(implemented in Python.)  This amazing bit of software is polymorphic
in the sense that you can feed it different compiler descriptions and
it becomes different compilers.

The underlying Meta-II virtual machine works just like an assembler to
read and "become" a compiler description, then it operates as a
syntax-driven compiler for the language described in the compiler
description.

It is simple enough to be understood by someone willing to take the
time, yet powerful enough to be used in earnest to develop "little
languages" for use in real projects.  The PUI includes a simple
compiler (a description in Meta-II) that generates control-flow
constructs for the firmware commands, illustrating the path from
hand-coded assembly to high-level languages.

(Those interested in further information regarding these issues are
urged to examine the work of the Viewpoints Research Institute.)

 - - -

Last but not least, the virtual computer in the PUI is a stack-based
Forth-like fully Functional Programming not-quite-language.  It mimics
the operation of the firmware but goes far beyond what that code is
capable of as it has the whole of Python and the host machine to work
with.

When you start the PUI it creates a "roost" directory (I apologize for
the pun) where it writes a Git repository (using a pure-Python Git
implementation called Dulwich) and two files: 'log' and
'system.pickle'.

Then the GUI starts and the user sees a window with two panes. On the
left is a listbox that shows the contents of the stack and on the
right is a text editor.

The 'log' file is kept in sync with the contents of the text
(auto-saved two seconds after the last edit) and the 'system.pickle'
file keeps a copy of the serialized state of the PUI and is updated
after every change to the virtual computer's state.  When either of
these files change a commit is made to the git repository.

This ensures that you never have to save (ever!) and you can never
lose your work (ever!).  When you re-open the PUI it reads the last
state and log from the "roost" directory and loads them, seamlessly
putting you in the exact spot where you left off.

You can use standard Git tools to examine and check out previous
history.  (Still to do: I want to add means for examining and
replaying histories as well as "cherry picking" objects and data from
previous states into the current one.)

In addition to the above automatic save mechanism, the text widget
includes undo/redo commands.

The stack-based virtual computer has a "dictionary" of command words
(like Forth) each of which operates solely on the stack and has no
side effects.  The virtual computer uses only those Python types that
are immutable (string/unicode, numbers, tuples) and this together with
the purely Functional command words means that the entire virtual
machine is pure Functional-Programming-style.

(One effect of this is that the whole machine state forms one
"persistent" data structure that captures the whole previous history
of every computation the machine performs as the user uses it to e.g.
write code for their chip(s).  This history is kept, serialized in the
'system.pickle' file, and could be made available to the user,
although at the moment it is discarded from the running PUI.  This
whole persistence mechanism is separate and orthogonal to the
git-based history store mentioned above.)

 - - -

The PUI has no menus, no buttons.

You execute commands by right-clicking on their names in the text editor.

Numbers can be put on the stack by right-clicking on them.

Strings can be put on the stack by selecting text and then, BEFORE
LETTING GO, clicking the right mouse button.

For example, start the PUI and type in two numbers. Right click on
each of the numbers and you'll see they appear on the stack.  Right
click "add" (type it in if it's not there) and you will see that the
two numbers have been replaced by their sum.

This is a summary of the mouse "chords" that you can use to control
the PUI (inspired by the Oberon OS and UI):

PUI Mouse Click Chord Commands:

   left - point and select
       * followed by right: copy selection to stack
       * followed by middle: cut selection to stack

   middle - paste, scroll
       * followed by left: paste stack to text
       * followed by right: pop stack to text

   right - command (execute word)
       * followed by left or middle: lookup word (put the named
         command onto the stack)

(Note: you use one mouse button and then, without letting go of the
first mouse button, use the second one to complete a mouse "chord".)

The default config.py includes key bindings as well:

  Selection-to-Stack:

    <F4>: Copy from selection to stack and system clipboard.

    <Shift-F4> or <F6>: Cut selection to stack and system clipboard.

  Stack-to-Insertion-Cursor:

    <F5>: Paste from stack to cursor leave stack undisturbed.

    <Shift-F5> or <F7>: Paste from stack to cursor and pop stack.

(You can edit these and add your own in the config file.)

The currently implemented command words are documented here:
  http://phoenixbureau.github.com/PigeonComputer/user_interface.html#library-of-words

 - - -

Fibonacci:  Try putting 1 on the stack (type it in and right-click on
it) then right-click "dup" to duplicate it and have two ints on the
stack.  Now repeatedly execute (right-click on) "tuck" and "add"...

Neat, eh?

And it works (thanks to Python's underlying implementation of "foo +
bar") whether you use string "1" numerals or integer digits.

 - - -

Command words can be put onto the stack and combined into new commands
using three primitives: Sequence, Branch, Loop.

See http://phoenixbureau.github.com/PigeonComputer/user_interface.html#xerblin-base
for more information.

Once a new command has been made it can be included in other commands
or given a name and inscribed in the dictionary and used like the
other commands.

 - - -

Whew!  If you are still reading, thank you.  There is a lot more to be
done and I am hoping to form classes in early January 2013.  If you
are interested please email me at forman.simon at gmail.com

You can also participate on Github and join the mailing list.
  * https://github.com/PhoenixBureau/PigeonComputer
  * https://groups.google.com/d/forum/pigeoncomputer

Warm regards,
~Simon P. Forman

More information about the Python-announce-list mailing list