The Io Language(iolanguage.org) |
The Io Language(iolanguage.org) |
Io allows you to write only and exactly what you meant with the least amount of non-essential complexity of any dynamically typed language I know. The lazy evaluation also allows you to take full advantage of code is data / data is code. That sounds like LISP, but whereas there the primitive is the list, in Io the primitive is the message.
My experience trying to write a larger project (a game, never finished) in Io was that it allowed me to make enormous progress initially, but suddenly reached a point in size of the project where the lack of static checking was (IMO) impeding my progress more than the elegance of the language was helping it.
(I also realized at that point I needed to re-implement some things in C++ for performance reasons, not because of Io per se but just because some things needed to be on the "native" side of the fence because things they touched also were.)
When I reached this point in the project, I found there was no clear path to translating what I'd developed into a static language (C++) because many of the ideas and systems I'd created in Io simply couldn't be expressed in C++ - or they made no sense there.
For example I'd created an embedded DSL (something Io excels at) for a data definition of the game objects. When I tried mindlessly converting these Io prototypes into C++ classes, they not only became too verbose they also lost all of the semantics of prototypical inheritance where "take a copy of another thing and tweak it" was my means of building up game objects by incremental refinement.
Its simplicity also made it great to write an interpreter for, including GC. However, nowadays the focus shifted to JIT, mostly via LLVM, which leaves such free-form languages unable to compete on performance, without significant effort.
I do fondly remember the endless explorative chats with Steve Dekorte and the other language geeks on IRC!
I’ve had a very similar experience with Haskell.
The Io Language - https://news.ycombinator.com/item?id=22796409 - April 2020 (24 comments)
Io Programming Language (new website design) - https://news.ycombinator.com/item?id=10605310 - Nov 2015 (73 comments)
Io language - https://news.ycombinator.com/item?id=8867575 - Jan 2015 (40 comments)
Io language - https://news.ycombinator.com/item?id=2624097 - June 2011 (35 comments)
The Io Language - https://news.ycombinator.com/item?id=1538835 - July 2010 (39 comments)
Io language - https://news.ycombinator.com/item?id=750830 - Aug 2009 (4 comments)
I later learned JavaScript and was extremely disappointed by its lackluster handling of prototypes. What's unfortunate is most programmers don't have experience with prototypes outside of JavaScript and I'm sorry to say its poor implementation of them has left a bad impression on the engineering mindshare. This ultimately culminated with ES6 introducing classes to replace what should have been the conceptually simpler and more flexible system.
Io is worth exploring, even if it's just out of curiosity. I'd especially recommend it to anyone whose only experience with prototypes is JavaScript.
I enjoyed the Io chapter, and JavaScript's prototypal inheritance made more sense to me after working through that chapter's exercises.
Curious what sort of work you do!
coming from:
at <llvm> CHash_at_(Unknown)
at <llvm> IoState_symbolWithUArray_copy_(../../../../Desktop/io/libs/iovm/source/IoState_symbols.c:44:1123)
at <llvm> IoState_symbolWithCString_length_(../../../../Desktop/io/libs/iovm/source/IoState_symbols.c:75:2141)
at <llvm> IoState_symbolWithCString_(../../../../Desktop/io/libs/iovm/source/IoState_symbols.c:79:2268)
at <llvm> IoState_retainedSymbol(../../../../Desktop/io/libs/iovm/source/IoState.c:245:8336)
at <llvm> IoState_setupQuickAccessSymbols(../../../../Desktop/io/libs/iovm/source/IoState.c:251:8564)
at <llvm> IoState_new_atAddress(../../../../Desktop/io/libs/iovm/source/IoState.c:106:2910)
at <llvm> IoState_new(../../../../Desktop/io/libs/iovm/source/IoState.c:240:8195)
at <llvm> main(../../../../Desktop/io/tools/source/main.c:37:599)
at org.graalvm.polyglot.Value.execute(Value.java:839)
It's a great dynamic language but suffers the same problems every other language with a small user-base suffers.
I've opened the issue: https://github.com/IoLanguage/io/issues/460
My very uninformed feeling is it might have to do with some C "trickery" too advanced for GraalVM.
Thank you for your work and time.
Io is a beautiful language that I got interested in about the time I was learning Ruby (2004 perhaps).
Also, for a few years, your pages were the top sources of information on Objective C!
Thanks for all the work!
https://viewsourcecode.org/why/hackety.org/2008/01/05/ioHasA...
wait, are YOU still active? ;) (I believe I was once a registered user of your app that, uh, downloaded a ton of movie clips into a… catalogue of sorts… you know the one…)
There’s a lot of older tech that deserves more love because it’s still great despite losing that new-language smell (I’m sure `io` fits that bill!). I’ve been messing around with the “es” shell and scripting language after getting frustrated with /(ba|c|z)?sh/ (bourne-lineage shells) quirks for the umpteenth time and finally discovering the “rc” family of shells (ok so was plan9 from the future or something? Because it had waaay more good ideas than it is credited for…)
I forked it but now I kinda want to slap a real test suite on it (ready for contributors…) and rebrand it as something new, maybe name it “holysh” since that was my joyful exclamation after reading the es docs and paper…
foo := Object clone do (
run := method(one, two,
writeln(one .. " is soooo " .. two)
)
) run("steve dekorte", "drunk")
"but it's just a lie" println
I handed over the domain in 2011 or 2012, can't remember. Good times back then :).
So it's old and dead? What's the point in posting this on HN?
Whether the language is "old" or "dead" has absolutely no bearing to whether it's interesting, inspirational, worthy of study, and so on. Not to mention that hackers should know CS history too.
[ ] The name of your language makes it impossible to find on Google
WHen I search on a different web search engine for "c" with my default web search engine that says it respects privacy, I start getting results for the C language about 5 items down from the top -- Pretty Good. When I search on said search engine, the C language Wikipedia article comes up first -- Excellent. Said engine also auto-fills programming language when I start to type that after io. My "respectful" web search engine doesn't auto-fill quite as quickly. If my new and extremely poorly named programming language is popular enough, the web search engines are able to figure it out.
io is the 5th result even on https://search.marginalia.nu/
The problem with io is that it already means something in a programing context, so adding extra programming related keywords won't help to disambiguate the search.
EDIT: thankfully, on a Mac with Homebrew, you can just 'brew install io'.
We're hiring[0] also (and our team has grown a bit since that last post).
Of course it is: javascript is prototypal out of practical convenience, namely that whipping up a prototypal object system was much easier to implement over a few weeks than a full-blown class-based one. It was never a philosophical / design intention, and thus the prototypal object system:
1. was never really good in the first place
2. was never significantly improved for convenience, some inroads were made in ES5, then promptly ignored thereafter
JS developers never came from or were interested in prototypal inheritance and that's doubly understandable from javascript being their first introduction to it (even after the ES5 improvements, and accounting for proprietary extensions like `__proto__`, it remained garbage), few will be motivated into looking up a Self environment to try it out after that, odds are much higher they'll jigger a frankenclass system and try to forget about prototypes entirely.
Talking about Self, and Io, and prototypes, having never really used either in anger I was surprised (and a bit dismayed) that Io's prototypes are a list thereof, that seems so much less sensible and pretty and flexible than Self's parent slots it just killed any interest I had in Io immediately.
And Io makes the same vocabulary mistake Javascript does (to the extent that I always assumed Io grew from an exploration of Javascript leaning more on prototypes, rather than growing from the original): while Self's OO is called prototypes-based, prototypes do not actually have much relevance to the runtime system: a prototype is the object you clone (shallowly), the objects you link to (via parent slots) are called / classified as mixins or traits depending whether they themselves have parents[0].
That is, Self's `copy` on clonables (as opposed to oddballs) is equivalent to Javascript's `Object.assign`, not `Object.create`, or IO's `clone` (an other name I find awful since it doesn't clone anything).
PS: "prototypal OO", not prototypical
The MOP from IO is beautiful.
To be fair, it is quite heavily biased toward the tech sphere. I try to make it balanced, but even so, not a single result about the poor woman who caught the eye of Zeus.
This is why I use your search engine. Thank you