It's never occurred to me to use Io for anything, but it's a wonderful mind expander.
Once you know one, or both of them, you can see what's going on so much more clearly.
I've played around with it a bit over the years: it is a fun little language.
Edit: fixed typo.
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.
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.)
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.
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.
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
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
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.
Generally if you're asking this question then you should just stick with the more well-known platforms.
Languages themselves don't have strengths and weaknesses. You need to compare everything else along with the language, the community, library support, stability of the implementation. And if you're looking for a comparison of these in a brand-new language, what you're looking for is not something it can offer. There is no community, libraries will be extremely spotty and not well documented. You also need to know the language it's implemented in, too, because you might need to debug the odd bug in the implementation yourself.
— the language is very mutable, almost all behaviours can be modified
— it's simple, all you can do is send messages to objects
— you can write DSLs and macro-like things without special macro support
— it's so dynamic you'll end up live-coding without realizing it
It has less syntax than Smalltalk, it's homoiconic like Lisp, but doesn't need support for macros because of the way messages are handled.
A not intolerable way of thinking of Io is it is to object calculus what Lisp is to lambda calculus. There are parts where that analogy breaks down but it's not a bad first approximation.
Apparently it's supposed to be really fast, too, for a pure-interpreted language, but unfortunately the name 'io' is unsearchable and I haven't found any references. (I think this is a major factor why nobody's ever heard of it.)
As with Go, appending 'lang' gives more luck: https://google.com/search?&q=iolang. (I still didn't find a reference for the speed, though.)
Io is no speed deamon, but for heavy computation, its easy to dip into compiled C or C++ libs, putting it in the same ballpark as an unjitted ruby, python, or lua.
Looking back, I wish I had written Io in Lua.
No, seriously, thank you for creating it. Although I hadn't had the chance to use it in production (most of my stuff is just numerical), Io is an incredibly enlightening language.
So learn it to be a better programmer.
How to make better landing page -> http://www.rust-lang.org/
Of course, I know this is just me bringing my biases to the thing, but that's the way it is.