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.
There was a great interview with Bruxe Tate on the "Mostly Erlang" podcast some time last year. He discusses the decision process behind the languages that were included in the original "Seven Languages" book. From what I gathered, the reason Io was included was because Javascript is simply too complicated and multi-paradigm. The syntax and reasoning behind Io is extremely simply and illustrates prototypal principles beautifully.
It's never occurred to me to use Io for anything, but it's a wonderful mind expander.
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.
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.)
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
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 little bit with Io, we have an experimental Io mode on CodeCombat, so you can play in your browser: 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
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
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 ?
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.
New languages are research projects, not startups. They don't really compete against each other.
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.
As someone who loves Io, it gets my attention because:
— 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.
Io's an attempt to combine the language minimalism of Smalltalk and Lisp. So you get a message-passing object oriented language with Lisp-like features like programs being their own parse tree, which you can manipulate at will at runtime.
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.)
What adrusi said is very spot on. I would add to what he said: Io is one of the few homoiconic languages that is not a Lisp. If you know what this means and what power this offers, I would argue this is a main selling point. If you don't know what this means or why this matters, it will be a meaningless differentiator.
AFAIK, Io isn't the kind of language to be compared with Go & co. - I don't think performance is one of its strong points. Rather it is a light and embeddable language, kind of like Lua.
I honestly wouldn't suggest it for production code, but I think that learning it gives you a great perspective on how powerful the right simple basic constructs can be.
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.)
[+] [-] talkingquickly|11 years ago|reply
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.
[+] [-] protomyth|11 years ago|reply
[+] [-] pselbert|11 years ago|reply
It's never occurred to me to use Io for anything, but it's a wonderful mind expander.
[+] [-] netghost|11 years ago|reply
Once you know one, or both of them, you can see what's going on so much more clearly.
[+] [-] zeroviscosity|11 years ago|reply
[+] [-] wiremine|11 years ago|reply
http://viewsourcecode.org/why/hackety.org/2008/01/05/ioHasAV...
I've played around with it a bit over the years: it is a fun little language.
Edit: fixed typo.
[+] [-] smosher_|11 years ago|reply
¹ http://web.archive.org/web/20080430135919/http://hackety.org...
[+] [-] pavlov|11 years ago|reply
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|11 years ago|reply
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_|11 years ago|reply
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|11 years ago|reply
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
[+] [-] nwinter|11 years ago|reply
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
[+] [-] platz|11 years ago|reply
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|11 years ago|reply
[+] [-] wildmXranat|11 years ago|reply
[+] [-] adrusi|11 years ago|reply
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.
[+] [-] vinceguidry|11 years ago|reply
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.
[+] [-] smosher_|11 years ago|reply
— 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.
edit: formatting
[+] [-] david-given|11 years ago|reply
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.)
[+] [-] nickbauman|11 years ago|reply
[+] [-] jevgeni|11 years ago|reply
[+] [-] netghost|11 years ago|reply
So learn it to be a better programmer.
[+] [-] PedroBatista|11 years ago|reply
[deleted]
[+] [-] lukasm|11 years ago|reply
How to make better landing page -> http://www.rust-lang.org/
[+] [-] JadeNB|11 years ago|reply