Commits

Anonymous committed de8a51f

Cleanups in preparation for release of version 1.0.

  • Participants
  • Parent commits 20ee8e0
  • Tags rel_1_0_2013_0315

Comments (0)

Files changed (5)

 -----------------------------------------------------------------------------
 
 The example ALPACA definitions of the Life and Wireworld automata written
-in ALPACA were written by Chris Pressey and are hereby placed in the public
-domain, as described in the following unlicense:
+in ALPACA, and all other example ALPACA sources in the `eg` directory, were
+written by Chris Pressey and are hereby placed in the public domain, as
+described in the following unlicense:
 
 -----------------------------------------------------------------------------
 

File README.markdown

       to Dead when 4 Alive or 7 Dead.
 
 See the file `ALPACA.markdown` in the `doc` directory for a complete
-specification of the ALPACA language, version 1.0-PRE.  This document is
+specification of the ALPACA language, version 1.0.  This document is
 written in [Falderal][] literate test suite format; the examples given in
 the spec are test cases, which can be run against an implementation.
 The `test.sh` script does this.
 
 This distribution also contains the reference implementation of ALPACA
-version 1.0-PRE, written in Python.  Its source is in the `src` directory
+version 1.0, written in Python.  Its source is in the `src` directory
 and `bin/alpaca` is a script to start it from the command line (no
 installation is required.)  See below for more information on the reference
 implementation.
 This was rewritten in version 0.90 to a hand-coded compiler in Perl 5
 that produces a Perl program that accepts an automaton form (a start
 state) as input, in the form of an ASCII text file, and animates it
-based on the rules of the defined cellular automaton.
+in the terminal based on the rules of the defined cellular automaton.
 
 Versions 0.93 and 0.94 succeeded version 0.90, but did not include any
 significant changes to the language, only to the reference implementation.
 Versions 0.91 and 0.92 possibly existed at some point as well, but they
 are now lost.
 
+(Note that these version numbers are highly inaccurate.  Version 0.94
+was not the ninety-fourth iteration of development.)
+
 Originally, the name ALPACA was an acronym for **a** **l**anguage for
 **p**rogramming **a**rbitrary **c**ellular **a**utomata.  However, as it
 was recognized by the author that the cellular automata expressible in
 ALPACA were far from arbitrary (limited to two dimensions and the Moore
 neighbourhood), a new backronym was sought.
 
-The currrent version of the ALPACA language is 1.0-PRE.  It has, unlike
-previous versions, a relatively formal specification, including many
-examples which serve as test cases.  Version 1.0-PRE adds several new
-features to the language, such as user-defined neighbourhoods, representations
-outside the realm of ASCII characters, and allowing a pre-defined CA
+The currrent version of the ALPACA language is 1.0.  It has, unlike previous
+versions, a relatively formal specification, including many examples which
+serve as test cases.  Version 1.0 adds several new features to the language,
+such as user-defined neighbourhoods and allowing a pre-defined CA
 configuration to be included with the CA description.  (This last enhancement
-makes ALPACA CA-complete: almost the same as Turing-complete, but there is no
-way to define, in ALPACA, what it means for a cellular automaton to halt.)
+makes ALPACA CA-complete, which is almost the same as Turing-complete except
+that there is no way to define, in ALPACA, what it means for a cellular
+automaton to halt.)
 
-ALPACA 1.0-PRE has an entirely new reference implementation, rewritten from
+ALPACA 1.0 has an entirely new reference implementation, rewritten from
 scratch in Python.
 
 Reference Implementation
 
 The reference implementation, `bin/alpaca`, can evolve a cellular automaton,
 given its rules as described in ALPACA along with an initial configuration
-(which may be supplied by the ALPACA description.)  It can also compile the
-ALPACA description to a program in Javascript that will evolve the cellular
-automaton, although this is more of a proof-of-concept at the moment.  (It
-passes all the test cases, but is not really well-developed or cleaned up.)
+(which may be supplied as part of the ALPACA description itself.)  It can also
+compile the ALPACA description to a program in Javascript that will evolve the
+cellular automaton, although this is somewhat of a proof-of-concept feature as
+of this writing.  (It passes all the test cases, but is not really
+well-architected or cleaned up.)
 
-### Tested ###
+### Testing ###
 
 The new implementation of ALPACA in Python has been tested with:
 
 *   Implement some option to halt under other, even more complex
     circumstances, such as some portion of the playfield matching some
     pattern.
-*   Possibly allow the halting predicate to be defined in the ALPACA
-    description itself somehow.  This would make ALPACA Turing-complete.
 *   Add the ability to display certain values (generation number,
     coordinates of top-left corner, etc.) in divider string, by making
     it a formatting string.
+
+Future Work
+-----------
+
+Possible ways in which the language could be extended in the future:
+
+*   Allow the halting predicate to be defined in the ALPACA description
+    itself somehow.  This would make ALPACA Turing-complete.
+*   Define how the presentation of the automaton could be styled using
+    (a subset of) CSS stylesheets (or something very similar.)

File doc/ALPACA.markdown

 The ALPACA Cellular Automaton Definition Language
 =================================================
 
-This document aims to describe version 1.0 of the ALPACA language.
-It is currently a work in progress.  Thus it is referred to as version
-1.0-PRE.
+This document describes version 1.0 of ALPACA, a language for defining
+cellular automata.
 
 The language described herein is mostly compatible with the version
 of the language which has existed until now (version 0.9x).  However, it
 extends it in some significant ways, and is backwards-incompatible with it
-in certain minor ways.  The reference implementation of 1.0-PRE that
+in certain minor ways.  The reference implementation of version 1.0 that
 accompanies this specification is included in the ALPACA reference
 distribution.
 
+In the remainder of this document, ALPACA refers to ALPACA version 1.0.
+
 Abbreviations
 -------------
 
 
 #### Class Memberships ####
 
-Any number of classes may be named after the representation declarations,
-with the name of each class preceded by `is`.  More information on this
-will be given in the "Classes" section below.
+In a state definition, any number of classes may be named after the
+representation declaration, with the name of each class preceded by `is`.
+More information on this will be given in the "Classes" section below.
 
 #### Transition Rules ####
 
     = -----
 
 Each state can belong to zero or more classes.  When it belongs to more
-than one, class the transition rules for each class are applied in order
+than one class, the transition rules for each class are applied in the order
 the classes are listed in the state definition.  In addition, the transition
 rules for the state itself are always applied first, before any class rules
 are considered.
 
 #### Membership ####
 
-In a transition rule, a class-inclusion predicate may be used by
-giving a state referent, the token `is`, and the name of a class.
-This expression evaluates to true if the state so referred to is a
-member of that class.
+In a transition rule, a class-inclusion predicate may be used by giving a
+state referent, the token `is`, and the name of a class.  This expression
+evaluates to true if the state so referred to is a member of that class.
 
 Example: a cellular automaton where `Dog`s and `Cat`s (both `Animal`s)
 switch to the other when the cell to the north is not an `Animal` and turn
     =  dd
     = -----
 
-(TODO: explain that diamond inheritance is not in practice a problem, as
-classes cannot contain any of their own state, which is what makes diamond
-inheritance a problem in most languages with MI.)
+Informative: diamond inheritance is not in practice a problem, as classes do
+not defined or contain any state (information) which is not in the state
+itself, which is what makes diamond inheritance problematic in most languages
+with multiple inheritance.
 
 ### Neighbourhoods ###
 
 way in which that could happen.
 
 `arrow-chain` and `identifier` tokens overlap; tokens beginning with a
-series of `v`s (lower-case letter "vee"s) will be interpreted as an `arrow-chain`.
-Thus, the text `vonNeumann` will be scanned as the arrow-chain `v` followed
-by the identifier `onNeumann`.  Until such time as this is addressed, avoid
-giving states, classes, and neighbourhoods names which begin with a lowercase
-`v`.  (Convention says to start these identifiers with uppercase letters
-anyhow.)
+series of `v`s (lower-case letter "vee"s) will be interpreted as an
+`arrow-chain`.  Thus, the text `vonNeumann` will be scanned as the arrow-chain
+`v` followed by the identifier `onNeumann`.  This may be addressed in a future
+version of ALPACA.  Until such time, avoid giving states, classes, and
+neighbourhoods names which begin with a lowercase `v`.  (Convention says to
+start these identifiers with uppercase letters anyhow.)
 
 Differences between ALPACA 1.0 and Previous Versions
 ----------------------------------------------------
 
-Previous versions of ALPACA did not support attribute representation
-declarations, or multiple representation declarations; they supported only
-a single quoted character to be used as the "appearance".
-
 Previous versions of ALPACA did not support arbitrary strings of arrows
 for state designators; instead, only arrow-chains in the set {`^`, `v`, `<`,
 `>`, `^<`, `^>`, `v<`, `v>`} were permitted.  In addition, previous versions
-supported eight compass directions (`n`, `ne`, etc) in place of arrow chains.
-This is no longer supported.  However, a future version might introduce a
-more "readable" alternative state referent syntax.
+supported eight compass direction abbreviations (`n`, `ne`, etc) in place of
+arrow chains.  This is no longer supported.
 
 Previous versions of ALPACA always assumed a Moore neighbourhood when making
 an adjacency predicate.  Other neighbourhoods could not be defined, and

File src/alpaca/backends/javascript.py

 """
-Backend for compiling ALPACA AST to Javascript.  Not yet complete.
+Backend for compiling ALPACA AST to Javascript.  Perhaps not complete.
 
 """
 

File src/alpaca/main.py

 alpaca [-afgIJpt] [-c backend] [-d string] description.alp [form.ca]
 
 Reference implementation of the ALPACA cellular automaton definition language,
-version 1.0-PRE.
+version 1.0.
 
 """