Io language

That's a great book. I credit it with getting me into functional programming.

There is a sequel to that book https://pragprog.com/book/7lang/seven-more-languages-in-seve... covering Lua, Factor, Elm, Elixir, Julia, miniKanren, and Idris.

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.

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.

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...

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.)

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

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.

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.

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.

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.

edit: formatting

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.

So learn it to be a better programmer.

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.)