Submitted by “This site is about Arc, a new dialect of Lisp. It’s unfinished, but usable, so we decided to release what we have so far. The current version compiles into MzScheme and structurally is as much a skin on MzScheme as a separate language. For example, Arc’s read is MzScheme’s, and so are Arc’s numbers and math operations. But from the average programmer’s point of view, Arc is no more similar to Scheme than any two Lisp dialects are to one another. Arc is designed above all for exploratory programming: the kind where you decide what to write by writing it. A good medium for exploratory programming is one that makes programs brief and malleable, so that’s what we’ve aimed for. This is a medium for sketching software.”
“When will that be? We have no idea. We reserve the right to take a very long time. It’s been almost 50 years since McCarthy first described Lisp. Another 2 or 3 aren’t going to kill anyone. So please don’t send us mail asking what Arc’s status is or when it will be done. (When it’s done, we’ll tell you.)”
Definetly, Paul Graham is not a RERO fan
The first part of the tutorial looked pretty much like ordinary Scheme/Lisp to me. Writing [… _ …] for (fn (_) (… _ …)) seems new to me although I think he already mentioned this idea in a previous article about Arc.
Is making (“foobar” 0) return ‘f’ his invention or does the same concept of using data structures like functions also exist in Scheme/Lisp?
Overall this doesn’t seem to be as revolutional as I had imagined after reading his articles. He got rid of some parentheses, granted.
I’d love to hear a professional Scheme/Lisp programmer’s opinion about Arc and in how far it brings something new to the table…
I think a lot of people are underwhelmed by the description in the tutorial, because feature-wise there don’t seem to be many changes. The compact block syntax is new, but using data structures as functions really isn’t. In Common Lisp, you can use the meta-object protocol to define a method that should be called if your object is called as a function. From there you can implement lookup semantics or whatever you want really. Of course, the notation isn’t as compact in Common Lisp because you have to use FUNCALL or APPLY to call an object as a function.
That said, I think the focus of Arc is in concision, and the benefits of that are going to be hard to show in a tutorial. The way the built-in features interact with each other can have a huge impact on the size and clarity of the code. Ironically enough, this is much the same problem Common Lisp has. It’s hard to tell just by reading the Hyperspec how elegantly CL’s standard library meshes with itself. Little things like the ordering of parameter names or little extra features added via keyword arguments can pay big dividends in real code.
Arc looks fairly conservative and IMHO will not be the next big Lisp. The good thing with Lisp has always been that it encourages experimentation and cross pollination. There are many interesting directions the language could go:
Goo (mini-Dylan, CLOS from the ground up)
Qi (build your own type system and pattern matching, based on Prolog)
Dylan (died so young, a real tragedy)
Ruby (that’s Smalltalk, but still)
Scheme (ML wannabe :-P)
Common Lisp (used to be great, now is getting a bit old and stubborn)
<insert your own hand made dialect here>
I have the feeling there’s a lot of unrealized potential for Lisp as a “dynamic” language (in the Dylan/CLOS direction). But it takes more than a smart design to make a language popular (it needs to form a community, get a commercial push etc)
That’s all we get?
I have to reserve judgement, I have not looked at the install or anything beyond the simple tutorial, but it looks like nothing more than a few macros on top of Scheme to me.
I have to assume there’s more to it. There HAS to be more to it.
There’s no new paradigm here that I can see. As the other poster suggested, it’s just a bit more concise than stock Scheme/CL. That’s not going to move a lot of folks I don’t think.
I really like Paul Graham’s essays, and one of his books, ANSI Common Lisp, was an important part of my life (I even still break it out on occasion for reference).
Arc has supposedly been a work in progress for 6-8 years now, right? Well, I gave the tutorial a once over and it’s definitely a stripped down Lisp dialect, that’s for sure. What I’m not seeing here is what will make this a “100 year” language as it is intended to be. What seperates Arc from the myriad of other Lisp dialects out there?
It seems to just be a fine-tuning of Lisp. The world would be a better place with an ultimate Lisp dialect, but I’m not seeing why that will be Arc just yet. There are a lot of really powerful functional languages out there now, like Haskell. Has programming language theory left Paul Graham behind (or, more appropriately, has Graham simply not kept up?).
Maybe it’s too early to comment, and I’ll be prepared to become an Arc fan if the final product does fulfill its world-changing goals in the end. I hope it does.