git @ Cat's Eye Technologies Pixley / master

Tree @master (Download .tar.gz) @master

History of Pixley Distribution

While [The Pixley Programming Language][] notes the changes, over
time, to the Pixley language itself, this file notes the changes
to this distribution: implementation, documentation,
example programs, and other "goodies".

### 1.0 ###

*   Initial distribution, implementing Pixley 1.0.

### 1.1 ###

*   Changed implementations to implement Pixley 1.1.

*   An enlarged test suite (previously mentioned).

*   A REPL (read-eval-print loop, or "interactive mode" interpreter), written
    in Scheme.

*   A statistics generator, written in Scheme, which counts the cons cells,
    symbol instances, and unique symbols present in a given s-expression.
    This was to measure the complexity of the Pixley interpreter.

*   A Mini-Scheme driver.  During my adventures in getting programs to run
    under AmigaOS 1.3, I compiled Mini-Scheme thereunder, and got Pixley to
    run under it by including the Pixley interpreter in Mini-Scheme's
    `init.scm` file and invoking it therein.  From this I conclude that,
    although I have not confirmed this is in a solid way by looking at the
    spec or anything, Pixley is also a strict subset of R4RS Scheme.

### 2.0 ###

*   Changed implementations to implement Pixley 2.0.

*   Bourne Shell scripts to run Pixley programs which are stored in individual
    files.  `` runs either a self-contained Pixley program from a
    single file, or evaluates a Pixley file to a function value and applies it
    to an S-expression stored in a second file.  `` does the same
    thing, but with Scheme, as a sanity-check.  By default these scripts use
    `plt-r5rs` for the Scheme interpreter, but that can be changed with an
    environment variable.

*   A P-Normalizer written in Pixley, probably the first non-trivial Pixley
    program to be written, aside from the Pixley interpreter itself.  P-Normal
    Pixley is a simplified version of Pixley where `let*` can only bind one
    identifer to one value and `cond` can only make one test, like Scheme's
    `if`.  This form is described more fully in the
    [Falderal literate test suite for the P-Normalizer][].

*   Test suites, written in [Falderal][], for both Pixley and the P-Normalizer.
    The original test suite written in Scheme, which runs successively deeper
    nested copies of the Pixley interpreter, is still included in the

*   A few other standalone Pixley examples, including `reverse.pix`,
    which reverses the given list.

### 2.0 revision 2012.0219 ###

*   The Bourne shell scripts `` and `` were replaced by a
    single script ``.  The idea behind this script is that it lets
    you constuct a "tower of interpreters" from a sequence of text files
    which contain S-expressions.  The first such S-expression is interpreted
    as Scheme, and may evaluate to a function value; the second such will be
    interpreted by that function, and may evaluate to another function value,
    and so forth, until there is an S-expression that evaluates to something
    besides a function value (and that result will be printed to standard
    output and `` will terminate.)

*   `` officially supports three implementations of Scheme that can
    be used as the base interpreter: `plt-r5rs` from the Racket distribution,
    `tinyscheme`, and `miniscm` version 0.85p1 (from our fork of the project
    on GitHub.)  Support for Scheme implementations is (more or less)
    capability-based, so adding support for other implementations should not
    be difficult (especially if they are similar to the three already

*   The test suite was put into Falderal 0.6 format and now uses ``
    to run each test case.  By default, it uses `plt-r5rs`, but can be told
    to use any of the Scheme implementations that `` supports.
    (Note: there is currently a failure when running one of the tests on a
    Pixley interpreter on a Pixley interpreter on `miniscm` that I have yet
    to track down.)

*   To match the expectations of ``, the Pixley self-interpreter was
    refactored to evaluate to a function value of one argument.  It was also
    simplified slightly, removing an unnecessary nested `cond`.

*   Various dialects of Pixley have been defined and described, and collected
    in the `dialect` directory of the distribution.  The dialects include
    Pifxley, which supports an `if` construct instead of `cond`; there is a
    Pixley interpreter written in Pifxley, and a Pifxley self-interpreter.
    There is also a dialect called Crabwell which allows values to be bound
    to, not just symbols, but arbitrary S-expressions.

*   A bug (a missing case) was fixed in the P-Normalizer.

*   The main Pixley documentation (what you're reading now) was converted
    to Markdown format.

*   Source code in the Pixley distribution was placed under a BSD-style

### 2.0 revision 2013.1024 ###

*   Funny story!  Remember when I said I was writing writing stuff in C to
    compile with DICE C under AmigaOS 1.3, and that what I decided to write
    was a Pixley interpreter in C?  Well, that implementation of Pixley,
    called `mignon`, has finally been included in the Pixley distribution.

*   Another implementation of Pixley, this time in Haskell and called `haney`,
    has also been included in the Pixley distribution.

*   The `` script has been refactored, since honestly it was kind of
    grody.  The abstraction layer which tries to make different implementations
    of Scheme behave the same has been split off into ``,
    while the responsibility of `` itself is only to build and run the
    tower of interpreters.  In addition to `plt-r5rs`, Mini-Scheme, and
    Tinyscheme, `` also supports the Husk Scheme interpreter.
    Finally, `` supports `mignon` and `haney` as well; even
    though they're not proper Scheme interpreters, they can be used as the
    base interpreter for a tower of Pixley interpreters.

*   The test suite has been modernized (for whatever "modern" means for
    Falderal) and enriched to handle testing these extra implementations.

### 2.0 revision 2015.0101 ###

(This also includes updates from revision 2014.0819 which I neglected to
list here previously.)

*   A new implementation of Pixley, in Javascript, which runs in a web browser
    which supports Web Workers.  As a bonus, it can depict the Pixley program
    as a series of nested, coloured rectangles.  You can see it online here:
    [Pixley installation at Cat's Eye Technologies][].

*   Wrappers to allow `pixley.scm` to be run under Scheme48 and the CHICKEN
    Scheme interpreter.

*   The test suite tries to find a reasonable Scheme implementation to run

*   Syntax for tests updated to Falderal 0.10.

*   `with-input-from-file` is an optional R5RS, so change the Scheme programs
    to not rely on it.

### 2.0 revision 2015.0723 ###

*   Small changes to the Javascript implementation.

### 2.0 revision 2017.1110 ###

*   Put all example programs as discrete files in the `eg/` directory.

*   Small changes to the Javascript implementation.

### 2.0 revision 2018.0622 ###

*   Split this HISTORY file off from [The Pixley Programming Language][].

*   Added a `build.seq` which details how to build `mignon` under
    AmigaDOS 1.3 using DICE C.

*   Added a `launch-pixley.js` file to the pixley.js demo, which is
    responsible for creating the UI, instead of coding it in HTML.

[The Pixley Programming Language]: doc/Pixley.markdown
[Falderal literate test suite for the P-Normalizer]: dialect/P-Normal.markdown
[Pixley installation at Cat's Eye Technologies]: