
Io language - polskibus
http://iolanguage.org/
======
talkingquickly
This is one of the languages covered in the excellent Prag Prog book "7
Languages in 7 Weeks" ([https://pragprog.com/book/btlang/seven-languages-in-
seven-we...](https://pragprog.com/book/btlang/seven-languages-in-seven-
weeks)).

It wasn't until I went through that books section on io and how prototypal
inheritance works that I felt like I really started to get a handle on
JavaScript.

~~~
netghost
Lua and IO are easily the two best ways to learn Javascript.

Once you know one, or both of them, you can see what's going on so much more
clearly.

~~~
mseepgood
> Lua and IO are easily the two best ways to learn Javascript.

I think REBOL is a better way to learn JavaScript.

------
wiremine
IO has been around for a while now, I remember it got some press back when
_why was still active:

[http://viewsourcecode.org/why/hackety.org/2008/01/05/ioHasAV...](http://viewsourcecode.org/why/hackety.org/2008/01/05/ioHasAVeryCleanMirror.html)

I've played around with it a bit over the years: it is a fun little language.

Edit: fixed typo.

~~~
smosher_
I'm fond of the post _Lazy Bricks, Lazy Mortar_ ¹ where he basically pulls a
rabbit out of a hat. It's a shame he didn't write more posts about Io.

¹
[http://web.archive.org/web/20080430135919/http://hackety.org...](http://web.archive.org/web/20080430135919/http://hackety.org/2008/01/10/lazyBricksLazyMortar.html)

------
pavlov
I used Io as an embedded scripting language in a video processing app. That
was something like 9 years ago. (Although Io's method dispatch is heavy, it
worked fine even on G4 Macs as the performance-intensive parts were C
functions anyway.)

Many years later I used Ruby, and I couldn't shake the feeling that Ruby had
the same goals as Io but only got half way.

~~~
djur
I like both Io and Ruby, but they have much different goals. The moderating
qualities that make Ruby seem halfway there to you were an intentional design
choice, because Matz wanted the language to feel familiar and friendly to
programmers coming from other languages. Ruby also took a lot of good things
from Perl (built-in regexes and other high-quality string processing
facilities, especially) that helped it fit into the Unix scripting ecosystem
in a way that purer languages like Io never would.

I would never consider embedding Ruby like I would Io or Lua (although mruby
is promising); on the other hand, part of what helped me learn and stick with
Ruby was using it for innumerable Unix scripting projects that would have been
much more awkward in a language like Io.

(Io also suffers from Scheme's problem, where a minimalist language is more
likely to calve a multitude of private and mutually incompatible frameworks.)

~~~
smosher_
> Io also suffers from Scheme's problem, where a minimalist language is more
> likely to calve a multitude of private and mutually incompatible frameworks.

I think that could be addressed in exactly the way Ruby addresses it, by
having a popular leading framework. Although in Io's case there are some gaps
in the standard library that I think need filling. For example, there's no
reason it has to be painful to do Unix scripting.

Another consideration is that frameworks in Io don't need to be brought into
conflict. It's still a trap, but it can be navigated and I really don't think
the situation is any worse than Ruby's.

------
smosher_
Convenient timing, I just started working on a project to pull my Io DSLs and
convenience protos into something more cohesive. So, plug:
[https://github.com/smosher/IoSetting](https://github.com/smosher/IoSetting)

Included are DSLs for List and Map construction, homoiconic pretty-printers
for List and Map and a few other things. I plan to do a lot of work to make
List nicer to use, plus some experimental constructs for... experimental
things.

I was going to wait until this got a little more mature before mentioning it
anywhere, but I figure I should mention it in this thread.

~~~
draegtun
Looks a good start.

I had plans for doing something like this a few years back myself. Here's the
only bit I managed to put on Github - [https://github.com/draegtun/Io-
Array](https://github.com/draegtun/Io-Array)

~~~
smosher_
Nice. I had seen some list-indexing uses of squareBrackets before. This looks
interesting, also reminds me I should write tests.

------
nwinter
If you want to play around a little bit with Io, we have an experimental Io
mode on CodeCombat, so you can play in your browser:
[http://codecombat.com/play](http://codecombat.com/play)

If you want to play around a lot with Io, you could help us extend the parser
so that it doesn't break after level 10. :P
[https://github.com/dariusf/iota](https://github.com/dariusf/iota)

------
platz
I heard something about Io being used in rendering pipelines for a film studio
(Pixar?).

The '7 languages in 7 weeks' book exposed a lot of people to Io, and it really
helped me understand JavaScript better at a time when most of the tutorials
out there were pretty confused

~~~
stevedekorte
From what I've been told, Pixar uses Io as an embeded scripting language for
their IT (Image Processing) application and for some build systems.

------
wildmXranat
Honest question: What are the main selling points of Io ? If I wanted to
compare its strengths and weaknesses against Go, Rust or even a less popular
language like Nim, where could I find that out ?

~~~
adrusi
It doesn't make much sense to compare it to any of those languages, it doesn't
try to solve the same problems. Io is a minimalist's scripting language in the
same space as Python, Ruby and Perl. It's also very suitable for embedding,
like Lua. It aims for a performance profile similar to Python's, which sets it
apart from some high-performing high-level languages like Lua, Javascript,
Java, Scala and Go.

Its incremental GC makes it somewhat suitable for game scripting. It uses a
single OS thread with coroutines, like Lua, although it supports multiple VMs
in the same process, so asynchronous message passing between two VMs on
separate threads might be easy enough to hack together.

It's good for people who like the minimalism and dynamic nature of the
language and what it lets them accomplish, so long as their task isn't CPU-
bound and doesn't require a rich library ecosystem.

~~~
justincormack
Lua supports multiple VMs in the same process too (there are no globals, you
always pass the Lua state).

------
lukasm
The page is confusing. Here is an example
[https://github.com/stevedekorte/io/blob/master/samples/misc/...](https://github.com/stevedekorte/io/blob/master/samples/misc/Account.io)

How to make better landing page -> [http://www.rust-
lang.org/](http://www.rust-lang.org/)

~~~
JadeNB
Surely it's unfair to expect the GitHub page for a language, much less some
deep-linked sub-page of it, to be a professional landing page? The page linked
from the post, iolanguage.org, is (intentionally) minimalist, in the spirit of
the language, but still a reasonably good landing page. (Also, as near as I
can tell, although it contains a link to GitHub, under 'source' where one
would expect, it contains no direct link to the page that you provide.)

~~~
lukasm
I don't expect "professionalism" or beautiful design, but give me the good
stuff first (use cases, samples).

~~~
draegtun
Only one click away from landing page is the Io Programming Guide. I've always
thought it was a well written introduction to Io -
[http://iolanguage.org/scm/io/docs/IoGuide.html](http://iolanguage.org/scm/io/docs/IoGuide.html)

