
Languages as Libraries (2011) [pdf] - mpweiher
http://www.ccs.neu.edu/racket/pubs/pldi11-thacff.pdf
======
ktRolster
IO language is a language that is similarly easy to extend. You might call it
a language prototyping language in the sense that it's easy to test out
language features (or whole new languages) in IO.

~~~
klibertp
It's called Io and yes - it's one of the most extensible languages I
encountered. Its main mechanism for extension resembles PicoLisp and fexprs -
any method can decide whether it wants its arguments evaluated or not. Coupled
with homoiconicity it allows for arbitrary code transformations on runtime -
and that's even before taking multiple, prototype-based inheritance and
arbitrary stack traversing[3] into account.

I wrote a PyParsing port in Io[1], for my text-based game I'm writing in Io.
It was a very interesting and unique experience - normally, when porting
things, you just go over the code and translate all of it line-by-line from
one language to the other. With Io, however, it was trivial to extend Io with
(most[2]) features that Python code required and in effect the code and the
language met in the middle. After adding certain things to the language most
of the "porting" was done with a set of basic regexes.

Now, the problem is Io is dead, is not being developed, and that's tragic. The
implementation is pretty straightforward, however the documentation is
severely lacking and the years without development left it far behind most
other languages.

I think it's a real shame and I was thinking about investing some time into Io
development myself, but my game project halted earlier this year diminishing
my motivation, not to mention I'm not sure if I would be up to the task.

Still, I'd be more than happy to help if someone would like to contribute to
the Io development. I would like to see Io resurrection and I think the
language still has a lot to offer even to the modern programmers.

[1]
[https://github.com/piotrklibert/ioparsing](https://github.com/piotrklibert/ioparsing)
\- see src/syntax.io, list literals, dict (map) literals and string
interpolation is implemented there.

[2] There's one problem I wasn't able to solve (yet), which is that the left
arg of the assignment operators are always evaluated - so no destructuring
assignment unfortunately. This is hardcoded in the VM, I even found where, but
ultimately didn't find the time to fix this.

[3] Think JavaScript arguments.callee but with first class namespaces.

~~~
agumonkey
impressive little language

iolanguage.org/guide/guide.html#Introduction

~~~
klibertp
I forgot to mention, Io also supports Lua-like coroutines. It's an incredibly
powerful language, mixing Smalltalk, Self and some Lisp in a non-image-based,
easy to use package, accessible to "normal programmers". I would really,
really like to see it developed again... and used, even if just a bit. I guess
I'm repeating myself here, so I'll stop.

~~~
agumonkey
were you involved in its development or just a loving user ?

~~~
klibertp
The latter... To be honest, I thought about contributing - Steve Dekorte, the
author, stopped developing the language, but is relatively responsive on
GitHub and merges PRs - but I had to stop that side-project just before doing
any real work on VM side. I wanted to add destructuring to the language and
wanted it to work with operators so that, given suitable definitions of [],
... and <\- this:

    
    
        [a,b,...,z] <- aLongList
    

would work - you could write destructuring support in pure Io if not for that
requirement.

I don't have the time for it right now (edit: and anyway, there's a limit to
how much a single person can do), though, so the only thing I can do is to
advocate the language and encourage its use. Which I'm trying to do right now
:-) I also have a blog post on Io waiting to be published, I'll post it once I
resolve the issues with my blog's domain.

