OOPSLA 2005: Io, a small programming language

(via Keith)

Io is small, pure object oriented, prototype-based programming language. The ideas in Io are mostly inspired by Smalltalk (all values are objects), Self, NewtonScript and Act1 (prototype-based differential inheritance, actors and futures for concurrency), LISP (code is a runtime inspectable/modifiable tree) and Lua (small, embeddable).

The paper and slides are available here.

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

Advanced Programming Language Design

Io leads to Amalthea which leads to Advanced Programming Language Design which says, "Most textbooks on programming languages cover the well-trodden areas of the field. In contrast, this book tries to go beyond the standard territory, making brief forays into regions that are under current research or that have been proposed and even rejected in the past."

Which sounds neat!

That is a different Io language

The Io language described in Advanced Programming Language Design and which Amalthea is based on is a different one by Raphael Levien. The Io language in the original post is by Steve Dekorte.

Re: 6 of one, 1/2 dozen of the other

Agreed. You know that, and I knew that - because the link I followed from io' to Amalthea explicitly says so - and I didn't say or mean to imply that io' == io. Apologies if my note discombobulated anybody!

(But I nevertheless found APLD, at least from the intro, to be cool, even if off-topic.)

Io == Pi?

I might be wrong, but the Io by Levien looks like just an alternative syntax for (polyadic) pi calculus. Any refutations?


We've had this discussion before. Io (this one) is explicitly based on continuation passing; π-calculus is rather strongly related to CPS. My understanding (if I remember what I read in APLD a couple years ago) is that Io had no particular concurrency ambitions. You may well be right: find a AST for each, set up an isomorphism and prove that it preserves semantics each way. This shouldn't be that hard; it'd probably be fun.

Reverse engineering?

find a AST for each
That could be tricky without ACM subscription (I mean Io, not pi, of course).

Any other sources for more or less complete specification?

Heck if I know

I believe there was an Io implementation also on or near the Amalthea page. If not I'm pretty sure there is one somewhere. However, reverse engineering of both AST and semantics is probably the quickest and easiest route (perhaps from APLD). My impression is that both are relatively simple for Io, at least the core parts. You should be able to get by with a simplification, at least to determine a yea or nay answer, though I think some of the crucial issues would not be completely obvious without a semantics.

Io did have concurrency ambitions

My understanding [...] is that Io had no particular concurrency ambitions.

Actually the ACM paper does discuss concurrency. It gives primitives for both spawning processes and creating CSP style channels.