Slashdot Mirror
Ioke Tries To Combine the Best of Lisp and Ruby
synodinos writes "Ola Bini, a core JRuby developer and author of the book Practical JRuby on Rails Projects, has been developing a new language for the JVM called Ioke. This strongly typed, extremely dynamic, prototype-based, object-oriented language aims to give developers the same kind of power they get with Lisp and Ruby, combined with a nice, small, regular syntax."
http://www.iolanguage.com/
Io is a small, prototype-based programming language. The ideas in Io are mostly inspired by Smalltalk (all values are objects, all messages are dynamic), Self (prototype-based), NewtonScript (differential inheritance), Act1 (actors and futures for concurrency), LISP (code is a runtime inspectable/modifiable tree) and Lua (small, embeddable).
How we know is more important than what we know.
Ola Bini has no beard. The only proof you need that this language will fail?
People think that s-expressions are a poor syntax. These people are wrong.
Seriously, if you give yourself the change to wrap your head around it, s-expressions are both elegant and powerful. Representing your code as a data structure is what makes lisp lisp. Take that away, and you might as well just use ML.
Another pocket language with idiosyncratic design choices that seem just right to the understimulated nerd looking for fame.
Anyone who loves or hates any language, platform, or manufacturer, doesn't know what they're talking about.
The parentheses just disappear after you've coded Lisp for a while. Also, try paredit.el for Emacs. With that turned on, you don't edit text, but sexps. It's wonderful, once you get used to it.
As for Lisp itself, well, 20 years ago did for the first time many of the things that mainstream languages today are just beginning to obtain, like closures, arbitrary lexical scoping, highly dynamic data structures, and (in Scheme's case) call/cc. One thing gcc just implemented is per-function compiler optimization settings. Common Lisp has had a facility for that since the beginning of time.
One thing that still isn't matched by other languages, however, is Lisp's macro system. It's far more powerful than C macros. You can define new control structures, implement sub-languages, and construct any higher-language construct you want. And these features you build all look just like native language constructs.
And don't even get me started o CLOS, which is one of the very few object-oriented systems to provide a clean multimethod dispatch solution.
If you're looking for a modernized lisp on the JVM, check out Clojure: http://clojure.org/
All the goodies of lisp, the JVM, and functional programming without all the bad outdated stuff. It's a very cool language.
I haven't used Self, but going by my experience with Javascript, prototype-based languages suck compared to conventional class/metaclass based ones.
Generally true. Javascript was never intended for writing large programs. The object system is basically a hack on top of dictionaries. That's easy to implement, but doesn't scale well.
This is one of the classic things one can do wrong in language design, and which tend to have to be fixed in later versions, painfully. Some other classic boners are leaving out a "bool" type (C and Python), not providing generics in a statically typed object-oriented language (C++ and Java), and not designing in separate compilation (ISO Pascal).
Ioke is cute, but there's just no really good reason for such a strange syntax, and it's going to turn too many people off. Using whitespace as an operator (really!) is probably a bad idea. The ability to change the operator precedence dynamically may be "fun", but does not lead to readable or maintainable code. Experience with "read macros" in LISP indicates that rewriting code during input isn't good for readability either. On top of all this, Ioke allows regular expressions in code, like Perl. (It's not clear from the description if you can use regular expressions in the read macros to rewrite the regular expressions in the code. I think you can.) So Ioke brings together the least readable features from four different languages.
People who come up with "l33t" ideas like this need to be put on maintenance programming of code written by others for six months or so.
Dylan had a very powerful macro system.
http://www.opendylan.org/
with all the advantages of a late-bound language.
Patriotism is a virtue of the vicious
Oh great, you combine the white-space-tab problem with the Lost in a Sea of Parentheses problem to get lost in a sea of white space ;-P
Table-ized A.I.
Not one single soul in the world who was ever going to make a language, is now not going to, because of that rant.
the same kind of power they get with Lisp and Ruby, combined with a nice, small, regular syntax
So, it's Lisp then?
Seriously... in terms of small regular syntaxes you don't get smaller and more regular than Lisp:
(source).
Next smallest and most regular syntax for a useful language is probably smalltalk, but that's too long to post here. It's worth noting that smalltalk (particularly its first-class statement blocks) was a heavy influence on ruby. Smalltalk also gets close to hitting the 'nice' requirement, which IMO Lisp is a long way from.
My eye sight must be getting bad... I misread this as:
Joke Tries to Combine the Best of Lisp and Ruby
You mean, "Right, it's a joke." In some browsers, the bottom of the j is cut off. I invented a new language too, named asdlkj. It is whitespace combined with brainf*ck that sits atop the microsoft JVM that compiles down to executable php.
Here is some sample code (tabs in [tab]):
+ + + + +[tab]<[. -]-.[tab] [tab]>-- [tab]<.+.
I'm still trying to understand what it's supposed to do.
Yes, people often don't see the point of things they've never tried, or of features that are missing from their current favourite language.
That's because C deals with how computers actually think. All this new stuff with languages is wonderful, and often has some uses in various cases, however none of it relates to how a computer actually works. C is a good "mid level" language. By that I mean it does a good job of structuring programs in terms of how they actually work on a processor, while still being fairly easy for a human to work with.
A lot of people get caught up in their "flavour of the month" language and forget that none of this relates to how computers actually work. For example yes, pointers are confusing and you can get in to trouble with them. However, that is actually how a processor handles things. It has registers that are pointers to memory locations of things it needs (like a pointer to the instruction to execute). So while more restrictive, managed references might be nice, they've nothing at all to do with how the processor works. That means you have to implement additional code overhead to deal with that sort of thing, and that you are losing the ability to optimise in certain ways.
Basically C is likely to remain strong until we just have more CPU power and memory than we know what to do with on all platforms (embedded included). Until then there is the need to generate optimised programs. To do that, you need to be able to write a program based on how the computer thinks, not on how you do.
We already have a programming language with a simple syntax and the strengths of Lisp and Ruby. It's called Lisp.
Badass Resumes
underscores? in lisp? are you mad!!?
(best-part-exists-p lisp)
i.e., hyphens as separators, p for predicate rather than the schemish question mark of you parent, and no need to quote lisp which is clearly being treated as a variable pointing to a language entity here, not a raw symbol in need of quotation.
Lisp did fairly well in the areas where the problems it solved particularly well were common; C and friends did well where the things it dealt with well were the main challenges. when C was conquering the world, the latter were more common than the former. Increasingly, the problems Lisp deals with well have become relevant to more software, but C-based languages are pretty entrenched (both in systems and in programmer's minds), so instead of Lisp seeing a resurgence, you see C-like languages with more and more Lisp-like features bolted on. (The same is true with "Smalltalk" in place of "Lisp", too.)