
The Io Language - pcr910303
http://iolanguage.org/
======
pcr910303
The Io language is a very simple & elegant homoiconic language. It was
introduced as one of the seven languages in the '7 Languages in 7 Weeks' book.
It's basically influenced by Lisp and Self, Smalltalk.

Two of the best Io-related blog posts by _why:

* Io Has a Very Clean Mirror - [https://viewsourcecode.org/why/hackety.org/2008/01/05/ioHasA...](https://viewsourcecode.org/why/hackety.org/2008/01/05/ioHasAVeryCleanMirror.html)

* Lazy Bricks, Lazy Mortar - [https://viewsourcecode.org/why/hackety.org/2008/01/10/lazyBr...](https://viewsourcecode.org/why/hackety.org/2008/01/10/lazyBricksLazyMortar.html)

And some code examples:

* Making an Account object - [https://github.com/IoLanguage/io/blob/master/samples/misc/Ac...](https://github.com/IoLanguage/io/blob/master/samples/misc/Account.io) * Bottles of Beer - [https://github.com/IoLanguage/io/blob/master/samples/misc/Bo...](https://github.com/IoLanguage/io/blob/master/samples/misc/BottlesOfBeer.io)

~~~
jedisct1
Same here, I discovered IO in 7 languages in 7 weeks, and loved how elegant it
was.

~~~
nanna
Curious about 7 Languages in 7 Weeks. For a reader new to all its languages,
is it actually readable in seven weeks, and if so, full time?

~~~
mst
I read it over a couple of weeks of sitting out in a pub beer garden on
evenings I wasn't doing anything else.

I almost certainly didn't learn everything there was to learn from the book in
the process, but I definitely felt like I'd got my value for money out of it.

~~~
nanna
Sounds about right for a couple of weeks in a summer locked indoors. Thanks

------
yakshaving_jgt
I learned about the Io language from working through the _Seven Languages in
Seven Weeks_ book, as I suppose most people did. In the book, it was suggested
that you should take a look at the example problems on the Io website. At some
point, those example problems disappeared.

I made a backup of those example problems here:
[https://gist.github.com/jezen/7972975](https://gist.github.com/jezen/7972975)

------
melicerte
Just discovering the language with this post. I'm must say I'm impressed by
the syntax. I've read part of the documentation and understand every code
example just by reading it, which is sufficiently rare to be mentioned.

I'm thinking to give it a try as a scrpiting language but find it too bad it
seems no longer maintained. Code has not changed since 2 years.

To note, there is a pure Go implementation of Io[1] which is actively worked
on.

[1]
[https://github.com/zephyrtronium/iolang](https://github.com/zephyrtronium/iolang)

~~~
melicerte
Also noticed this project[1] by IO author which lets you use Python 3 within
Io. The readme is rather short but there is a nice example in the sample/
folder[2].

[1]
[https://github.com/IoLanguage/Python](https://github.com/IoLanguage/Python)

[2]
[https://github.com/IoLanguage/Python/blob/master/samples/Usi...](https://github.com/IoLanguage/Python/blob/master/samples/UsingPython.io)

(edited for formatting)

------
gridlockd
The more I program, the less do I value any of these overly dynamic features
and elegant aesthetics.

However, I have come to greatly value robust tooling surrounding a language,
to the point where I believe designing a language that makes the creation of
such tooling difficult (or impossible) is a terrible trade-off.

~~~
effie
> language that makes the creation of such tooling difficult (or impossible)
> is a terrible trade-off.

Any examples? Does Io make such trade-off?

------
dang
Two threads from 2015:

[https://news.ycombinator.com/item?id=10605310](https://news.ycombinator.com/item?id=10605310)

[https://news.ycombinator.com/item?id=8867575](https://news.ycombinator.com/item?id=8867575)

(Links for the curious. Reposts are fine after a year:
[https://news.ycombinator.com/newsfaq.html](https://news.ycombinator.com/newsfaq.html))

------
klibertp
Some 2 years ago Io got a new way of defining setters, which allowed for
implementing destructuring bind ([a,b,c] := someTriple). It took me the better
part of a year, but it was very rewarding. I put a write-up on my blog, which
might be of interest if you'd like to know more about Io interpreter
internals:

[https://klibert.pl/posts/adding_destructuring_bind_to_io.htm...](https://klibert.pl/posts/adding_destructuring_bind_to_io.html)

------
nickbauman
Io seems to be abandoned. Is anyone using it?

~~~
ghayes
> Io was created in 2002 and actively developed until 2008. Thanks to everyone
> that made contributions. Patches are still welcome.

> A JS/WASM implementation might happen some day...

From [http://iolanguage.org/about.html](http://iolanguage.org/about.html)

------
dognotdog
Io has been around for a long time, indeed. I thought it was great, writing an
Io interpreter in C was a lot easier than almost anything else, so for
learning language internals, it is awesome, and I'd even say a great companion
to LISP, to play around with how different first principles affect programming
-- something that is obscured in mainstream languages, making it harder to
learn how the guts work.

------
PedroBatista
My graduation final project was done in Io more than a decade ago.

The language is generally great but it needed some financial muscle on the
implementation side as every language do, this stuff is hard.

~~~
dangerbird2
It also has really bad SEO potential due to its name. Go managed to overcome
the issue, but it had google on its side.

------
edem
Why?

~~~
melicerte
;-)

