[Gnu-arch-users] Pika milestone: character or cons?

[Tom Lord]

A new release from the Pika Scheme project is available at the
mirrors:

  |                                                                |
  |    http://regexps.srparish.net/src/pika/                       |
  |    http://arch.quackerhead.com/~lord/releases/pika             |
  |                                                                |


This release is called pika-0.1pre1 and here's what's new:



~ Character Type Implemented
~ Nil Type Implemented
~ Cons Pair Type Implemented

  Each of the above includes the core run-time system interface
  to the type, reference manual documentation for that interface,
  and unit tests.


* How to Get Involved

  If you believe that you're competent to help specify and/or implement
  a Scheme dialect and VM, and would like to help in that regard, 
  please sign up for the pika-dev mailing list:

        http://mail.nongnu.org/mailman/listinfo/pika-dev

  and let's take it from there.


  Also:  I am living these days as a "free software Internet busker"
  which means that I write free software, and then from time to time
  "pass the hat" to collect some money to get by on.

  You can read about my other projects (the arch revision control
  system, the hackerlab C library, and the package-framework
  configure/build framework) _and_ find my glorious "paypal link" at
  either of these mirrors:

        http://regexps.srparish.net/www/
        http://arch.quackerhead.com/~lord/

  Thank you for your support.



-t


https://www.paypal.com/xclick/business=lord%40emf.net&item_name=support+for+arch+and+other+free+software+efforts+by+tom+lord&no_note=1&tax=0&currency_code=USD



                            What is Pika?

* The Goal

  The primary objective of this project is to build an implementation of
  Scheme which:

    * can run as an interpreter
    * is written in relatively portable C
    * has good performance running interpreted code
    * is easily extended by writing new primitive functions in C
    * is easily targeted by a Scheme->C compiler
    * has a precise garbage collector
    * can have an incremental garbage collector
    * implements R5RS precisely
    * has a small-source-code and small-footprint core
    * supports multiple instances in a single process
    * has a firmly abstract interface to the representation of Scheme types
    * can run multi-threaded programs
    * has first-class environments
    * has a low start-up time
    * has a complete set of features for Posix systems programming
    * has a richy featureful string and buffer type, including
      superlative Unicode support

  I make no argument that {INSERT YOUR FAVORITE SCHEME IMPLEMENTATION
  HERE} doesn't already satisfy all or most of those requirements.  I
  almost certainly respectfully disagree -- but I'm not interested in
  arguing.  I agree that there are several quite virtuous
  implementations and will presume that your favorite is likely to be
  one of them.

  The approach that I'm taking with Pika is to define an abstract
  virtual machine which "puns" well as several different things.  The
  VM should be:

    * suitable for direct interpretation, as by a bytecode engine

    * an easy target for a simplistic Scheme compiler

    * a useful intermediate target for a native or ->C Scheme
      compiler

    * suitable for a static code safety verifier, similar to Java's

    * a useful intermediate target for a native JIT compiler