X-Git-Url: http://git.hcoop.net/jackhill/mal.git/blobdiff_plain/9044b1fdb1e2f52a5ac476e8a4c6ccd00f5d6bec..2af103066c632ca3d7bf8b0436f6b05f91700bb3:/README.md

diff --git a/README.md b/README.md
index f5cb0780..143fc1ed 100644
--- a/README.md
+++ b/README.md
@@ -6,18 +6,22 @@
 
 Mal is a Clojure inspired Lisp interpreter.
 
-Mal is implemented in 46 languages:
+Mal is implemented in 59 languages:
 
+* Ada
 * GNU awk
 * Bash shell
 * C
 * C++
 * C#
+* ChucK
+* GNU CLISP
 * Clojure
 * CoffeeScript
 * Crystal
 * D
 * Elixir
+* Emacs Lisp
 * Erlang
 * ES6 (ECMAScript 6 / ECMAScript 2015)
 * F#
@@ -28,20 +32,28 @@ Mal is implemented in 46 languages:
 * GNU Guile
 * Haskell
 * Haxe
+* Io
 * Java
 * JavaScript ([Online Demo](http://kanaka.github.io/mal))
 * Julia
 * Kotlin
+* Logo
 * Lua
 * GNU Make
 * mal itself
 * MATLAB
 * [miniMAL](https://github.com/kanaka/miniMAL)
 * Nim
+* Object Pascal
+* Objective C
 * OCaml
 * Perl
+* Perl 6
 * PHP
+* PL/pgSQL (Postgres)
+* PL/SQL (Oracle)
 * Postscript
+* PowerShell
 * Python
 * RPython
 * R
@@ -52,6 +64,7 @@ Mal is implemented in 46 languages:
 * Swift
 * Swift 3
 * Tcl
+* VHDL
 * Vimscript
 * Visual Basic.NET
 
@@ -79,8 +92,12 @@ The mal (make a lisp) steps are:
 
 Mal was presented publicly for the first time in a lightning talk at
 Clojure West 2014 (unfortunately there is no video). See
-mal/clojurewest2014.mal for the presentation that was given at the
-conference (yes the presentation is a mal program).
+examples/clojurewest2014.mal for the presentation that was given at the
+conference (yes the presentation is a mal program). At Midwest.io
+2015, Joel Martin gave a presentation on Mal titled "Achievement
+Unlocked: A Better Path to Language Learning".
+[Video](https://www.youtube.com/watch?v=lgyOAiRtZGw),
+[Slides](http://kanaka.github.io/midwest.io.mal/).
 
 If you are interesting in creating a mal implementation (or just
 interested in using mal for something), please drop by the #mal
@@ -90,6 +107,34 @@ FAQ](docs/FAQ.md) where I attempt to answer some common questions.
 
 ## Building/running implementations
 
+The simplest way to run any given implementation is to use docker.
+Every implementation has a docker image pre-built with language
+dependencies installed. You can launch the REPL using a convenience
+target in the top level Makefile (where IMPL is the implementation
+directory name and stepX is the step to run):
+
+```
+make DOCKERIZE=1 "repl^IMPL^stepX"
+    # OR stepA is the default step:
+make DOCKERIZE=1 "repl^IMPL"
+```
+
+
+### Ada
+
+*The Ada implementation was created by [Chris Moore](https://github.com/zmower)*
+
+The Ada implementation was developed with GNAT 4.9 on debian. It also
+compiles unchanged on windows if you have windows versions of git,
+GNAT and (optionally) make.  There are no external dependencies
+(readline not implemented).
+
+```
+cd ada
+make
+./stepX_YYY
+```
+
 ### GNU awk
 
 *The GNU awk implementation was created by [Miutsuru kariya](https://github.com/kariya-mitsuru)*
@@ -111,7 +156,8 @@ bash stepX_YYY.sh
 ### C
 
 The C implementation of mal requires the following libraries (lib and
-header packages): glib, libffi6 and either the libedit or GNU readline library.
+header packages): glib, libffi6, libgc, and either the libedit or GNU readline
+library.
 
 ```
 cd c
@@ -148,6 +194,29 @@ make
 mono ./stepX_YYY.exe
 ```
 
+### ChucK
+
+*The ChucK implementation was created by [Vasilij Schneidermann](https://github.com/wasamasa)*
+
+The ChucK implementation has been tested with ChucK 1.3.5.2 on Arch
+Linux.
+
+```
+cd chuck
+./run
+```
+
+### GNU CLISP
+
+*The GNU CLISP implementation was created by [Iqbal Ansari](https://github.com/iqbalansari)*
+
+The implementation has been tested with GNU CLISP v2.49 on Ubuntu 16.04, 14.04 and 12.04
+
+```
+cd clisp
+make
+./run
+```
 
 ### Clojure
 
@@ -171,7 +240,7 @@ coffee ./stepX_YYY
 
 *The Crystal implementation of mal was created by [Linda_pp](https://github.com/rhysd)*
 
-The Crystal implementation of mal has been tested with Crystal 0.10.0.
+The Crystal implementation of mal has been tested with Crystal 0.18.4.
 
 ```
 cd crystal
@@ -194,6 +263,22 @@ make
 ./stepX_YYY
 ```
 
+### Emacs Lisp
+
+*The Emacs Lisp implementation was created by [Vasilij Schneidermann](https://github.com/wasamasa)*
+
+The Emacs Lisp implementation of mal has been tested with Emacs 24.3
+and 24.5.  While there is very basic readline editing (`<backspace>`
+and `C-d` work, `C-c` cancels the process), it is recommended to use
+`rlwrap`.
+
+```
+cd elisp
+emacs -Q --batch --load stepX_YYY.el
+# with full readline support
+rlwrap emacs -Q --batch --load stepX_YYY.el
+```
+
 ### Elixir
 
 *The Elixir implementation was created by [Martin Ek (ekmartin)](https://github.com/ekmartin)*
@@ -255,7 +340,7 @@ mono ./stepX_YYY.exe
 *The Factor implementation was created by [Jordan Lewis (jordanlewis)](https://github.com/jordanlewis)*
 
 The Factor implementation of mal has been tested with Factor 0.97
-([factorcode.org](factorcode.org)).
+([factorcode.org](http://factorcode.org)).
 
 ```
 cd factor
@@ -338,6 +423,16 @@ make all-js
 node ./stepX_YYY.js
 ```
 
+### Io
+
+*The Io implementation was created by [Dov Murik](https://github.com/dubek)*
+
+The Io implementation of mal has been tested with Io version 20110905.
+
+```
+cd io
+io ./stepX_YYY.io
+```
 
 ### Java 1.7
 
@@ -380,6 +475,17 @@ make
 java -jar stepX_YYY.jar
 ```
 
+### Logo
+
+*The Logo implementation was created by [Dov Murik](https://github.com/dubek)*
+
+The Logo implementation of mal has been tested with UCBLogo 6.0.
+
+```
+cd logo
+logo stepX_YYY.lg
+```
+
 ### Lua
 
 Running the Lua implementation of mal requires lua 5.1 or later,
@@ -424,6 +530,29 @@ nimble build
 ./stepX_YYY
 ```
 
+### Object Pascal
+
+The Object Pascal implementation of mal has been built and tested on
+Linux using the Free Pascal compiler version 2.6.2 and 2.6.4.
+
+```
+cd objpascal
+make
+./stepX_YYY
+```
+
+### Objective C
+
+The Objective C implementation of mal has been built and tested on
+Linux using clang/LLVM 3.6. It has also been built and tested on OS
+X using XCode 7.
+
+```
+cd objc
+make
+./stepX_YYY
+```
+
 ### OCaml 4.01.0
 
 *The OCaml implementation was created by [Chris Houser (chouser)](https://github.com/chouser)*
@@ -474,6 +603,16 @@ cd perl
 perl stepX_YYY.pl
 ```
 
+### Perl 6
+
+*The Perl 6 implementation was created by [Hinrik Örn Sigurðsson](https://github.com/hinrik)*
+
+The Perl 6 implementation was tested on Rakudo Perl 6 2016.04.
+
+```
+cd perl6
+perl6 stepX_YYY.pl
+```
 
 ### PHP 5.3
 
@@ -485,6 +624,45 @@ cd php
 php stepX_YYY.php
 ```
 
+### PL/pgSQL (Postgres SQL Procedural Language)
+
+The PL/pgSQL implementation of mal requires a running Postgres server
+(the "kanaka/mal-test-plpgsql" docker image automatically starts
+a Postgres server). The implementation connects to the Postgres server
+and create a database named "mal" to store tables and stored
+procedures. The wrapper script uses the psql command to connect to the
+server and defaults to the user "postgres" but this can be overridden
+with the PSQL_USER environment variable. A password can be specified
+using the PGPASSWORD environment variable. The implementation has been
+tested with Postgres 9.4.
+
+```
+cd plpgsql
+./wrap.sh stepX_YYY.sql
+    # OR
+PSQL_USER=myuser PGPASSWORD=mypass ./wrap.sh stepX_YYY.sql
+```
+
+### PL/SQL (Oracle SQL Procedural Language)
+
+The PL/pgSQL implementation of mal requires a running Oracle DB
+server (the "kanaka/mal-test-plsql" docker image automatically
+starts an Oracle Express server). The implementation connects to the
+Oracle server to create types, tables and stored procedures. The
+default SQL*Plus logon value (username/password@connect_identifier) is
+"system/oracle" but this can be overridden with the ORACLE_LOGON
+environment variable. The implementation has been tested with Oracle
+Express Edition 11g Release 2. Note that any SQL*Plus connection
+warnings (user password expiration, etc) will interfere with the
+ability of the wrapper script to communicate with the DB.
+
+```
+cd plsql
+./wrap.sh stepX_YYY.sql
+    # OR
+ORACLE_LOGON=myuser/mypass@ORCL ./wrap.sh stepX_YYY.sql
+```
+
 ### Postscript Level 2/3
 
 The Postscript implementation of mal requires ghostscript to run. It
@@ -495,6 +673,16 @@ cd ps
 gs -q -dNODISPLAY -I./ stepX_YYY.ps
 ```
 
+### PowerShell
+
+The PowerShell implementation of mal requires the PowerShell script
+language. It has been tested with PowerShell 6.0.0 Alpha 9 on Linux.
+
+```
+cd powershell
+powershell ./stepX_YYY.ps1
+```
+
 ### Python (2.X or 3.X)
 
 ```
@@ -579,8 +767,7 @@ make
 ### Swift 3
 
 The Swift 3 implementation of mal requires the Swift 3.0 compiler. It
-has been tested with the development version of the Swift 3 from
-2016-02-08.
+has been tested with Swift 3 Preview 3.
 
 ```
 cd swift3
@@ -600,6 +787,18 @@ cd tcl
 tclsh ./stepX_YYY.tcl
 ```
 
+### VHDL
+
+*The VHDL implementation was created by [Dov Murik](https://github.com/dubek)*
+
+The VHDL implementation of mal has been tested with GHDL 0.29.
+
+```
+cd vhdl
+make
+./run_vhdl.sh ./stepX_YYY
+```
+
 ### Vimscript
 
 *The Vimscript implementation was created by [Dov Murik](https://github.com/dubek)*
@@ -630,7 +829,7 @@ mono ./stepX_YYY.exe
 
 ### Functional tests
 
-The are nearly 500 generic functional tests (for all implementations)
+The are over 600 generic functional tests (for all implementations)
 in the `tests/` directory. Each step has a corresponding test file
 containing tests specific to that step. The `runtest.py` test harness
 launches a Mal step implementation and then feeds the tests one at
@@ -764,43 +963,37 @@ make "stats-lisp^IMPL"
 make "stats-lisp^js"
 ```
 
-## Docker test environment
+## Dockerized testing
 
-There is a Dockerfile included in the `tests/docker` directory that
-builds a docker image based on Ubuntu Utopic that contains everything
-needed to run tests against all the implementations (except for MATLAB
-which is proprietary/licensed).
+Every implementation directory contains a Dockerfile to create
+a docker image containing all the dependencies for that
+implementation. In addition, the top-level Makefile contains support
+for running the tests target (and perf, stats, repl, etc) within
+a docker container for that implementation by passing *"DOCKERIZE=1"*
+on the make command line. For example:
 
-Build the docker image using a provided script. WARNING: this will
-likely take over an hour to build from scratch and use more 3 GB of disk:
-```bash
-./tests/docker-build.sh
 ```
-
-Launch a docker container from that image built above. This will
-volume mount the mal directory to `/mal` and then give you a bash
-prompt in the container. You can then run individual mal
-implementations and tests:
-```bash
-./tests/docker-run.sh
+make DOCKERIZE=1 "test^js^step3"
 ```
 
-You can also specify a command to run within the container. For
-example, to run step2 tests for every implementation (except MATLAB):
-```bash
-./tests/docker-run.sh make SKIP_IMPLS="matlab" "test^step2"
+Existing implementations already have docker images built and pushed
+to the docker registry. However, if
+you wish to build or rebuild a docker image locally, the toplevel
+Makefile provides a rule for building docker images:
+
 ```
+make "docker-build^IMPL"
+```
+
 
 **Notes**:
-* JVM-based language implementations (Java, Clojure, Scala): you will
-  need to run these implementations once manually first before you can
-  run tests because runtime dependencies need to be downloaded to
-  avoid the tests timing out. These dependencies are download to
-  dot-files in the /mal directory so they will persist between runs.
-* Compiled languages: if your host system is different enough from
-  Ubuntu Utopic then you may need to re-compile your compiled
-  languages from within the container to avoid linker version
-  mismatches.
+* Docker images are named *"kanaka/mal-test-IMPL"*
+* JVM-based language implementations (Groovy, Java, Clojure, Scala):
+  you will probably need to run these implementations once manually
+  first (make DOCKERIZE=1 "repl^IMPL")before you can run tests because
+  runtime dependencies need to be downloaded to avoid the tests timing
+  out. These dependencies are download to dot-files in the /mal
+  directory so they will persist between runs.
 
 
 ## License