Arc: Where are we going?
arclanguage.org
arclanguage.org
If I were an arclanguage community member reading this and seeing pg's responses, I would not feel better.
The whole situation sounds like a big mess especially considering lisp's history of "community fragmentation and trivially incompatible implementations."
I sincerely hope things get better.
CL was in my opinion (and in the opinion a lot of Lisp hackers) a disaster in that respect. Before CL, Lisp had evolved rapidly by spawning new dialects. Once CL was established as the standard, this evolution practically stopped.
http://journal.dedasys.com/articles/2006/02/18/maximizers-sa...
My gut feeling is that there's a 'right' balance that's hard to find. If you just want to explore and be creative and push the limits, that kind of fragmentation is probably good, or at least not harmful. If you want to create something that people, say, base their businesses on, I think that it is not as positive. People get nervous about picking the 'right' one; beginners are especially confused, because they may not even have acquired the knowledge to decide what is 'right'. Lots of hacking goes into implementations, rather than libraries, and libraries may not work on all implementations, further exacerbating the 'which one' problem, which now involves looking at which libs run where.
Another part of the "problem" is that if you're aiming for "fun and experimentation", you are in a somewhat different (enviable?) position than most programming language creators: you've written about and popularized the language already, and are somewhat famous yourself, guaranteeing Arc a wide audience, something that is probably likely to attract more 'consumer' types than 'creators'. They're the ones who will be grumpy about not having something stable.
That sounds pretty good to me, actually.
I don't see why aiming for "fun and experimentation" would put me in a different position from other language designers. It's not like anyone does this for a living. I bet most of them started out working on their language in the spirit of intellectual adventure, then gradually got dragged into being motivated more by duty and eminence, till eventually like poor Guido their time was all taken up thinking about character sets. That sounds to me like something one ought to resist. Doesn't it to you?
Amusingly enough, you can see the pressure in action all over this thread, e.g.
http://news.ycombinator.com/edit?id=343663
I'm pretty good at resisting though ;)
In particular, you do not want everything in Arc to be an object. But the typical way other programming languages deal with Unicode nicely is to have different classes that implement a common string interface. So how can Arc approach the string encoding problem without making everything an object? I don't know, but I do think it's an important question.
I'm actually fascinated by these 'social science' (i.e. not really a science) aspects of programming languages. If you think about it, programming languages are all about people, how they interact with computers, and how they interact with one another to solve complex problems.
Good luck, and I'll keep trying Arc 3 or whatever future stuff there is. I would love a successful language with real macro capability.
http://www.paulgraham.com/core.html
I'm not deeply committed to the current approach to iteration. But I don't want to switch to something more complicated till I can prove it's a net win. My standard of proof is whether the proposed language change will make the source of a real program shorter. So if you have an idea for a new iteration abstraction that would make some piece of code in news.arc shorter, please show me the source before and after. (You don't have to implement the new abstraction; just show me what code using it would look like.)
But really the question is whether any object-oriented philosophy is necessary. My take is, let's say you write a function in Arc that operates on lists. It's recursive using car and cdr. Now ideally, you could also run that function on anything else that is list-like. But in Arc, car only works on lists. Maybe you can fix this without making everything an object, that'd be fine by me.
In practice modern programming languages are tending towards a default dynamic-array-like datastructure that supports both random access and amortized-O(1) append. This is so convenient for hacking programs together, I can't believe the 100-year language won't have this as a very basic part of the system. But Arc doesn't do this. In news.arc you have a very Lisp-list-centric way of programming. But I think for many problems less restrictive datatypes are the most convenient. Hash tables and dynamic arrays need to be just as easy as Lisp lists. This is the Python way, the Ruby way, and I think the way of the 100-year language. But I don't know how to make iteration on any of these look equivalent without making the core of the language be more object oriented.
Are you saying you believe you need some OO elements of polymorphism on car and cdr? Not sure you need these - there are loop constructs that let for "for each do X". With macros you could make this do almost any type of iteration.
I might be missing your point though, as I'm not sure how Objects help in this scenario.
Why can't you iterate on hash tables in Arc? ...or another related question, what do you mean by iterate in the context of a hash table?
Similarly... Isn't a dynamic array just a list? Or it is specifically the performance of this that you're concerned about - surely this is just an optimisation step rather than a hole in the language?... Either way, I'll agree that they're convenient for hacking programs together :)
Yes, it is possible to use macros to write code that works over both lists and other iterable things. But that isn't the most natural usage; Arc encourages you to write recursive functions using car and cdr. And if you have a lot of code using car and cdr, you have to rewrite that if you want to convert data from lists to another data type. Objects could possibly give you a polymorphic car and cdr, similar to Clojure, so you just don't have to worry about "what sort of iterable object" a function is going to work on.
As far as dynamic arrays versus lists, you can consider it "just an optimization step" as long as you can swap in a dynamic array for a list later on without changing your code. But that isn't possible in Arc because you will have to replace car/cdr with other iteration constructs. I think it's a little unfair to consider the difference between Lisp lists and dynamic arrays just a matter of optimization - there are plenty of things that you can't even play around with when random access is O(n). E.g. randomly shuffling the lines of a large text file.
> But I don't know how to make iteration on any of these look equivalent without making the core of the language be more object oriented.
Haskell's typeclasses would work, as well, and in practice seem to generalize far better. Instead of restricting the iterator used to a specific type, restrict it to any type that supports the interface of iteration. (It's kind of like duck-typing that is verified at compile-time.) It sounds like Clojure has a similar mechanism.
Adding very powerful and general capabilities to syntax, as Fortress does, also reduces the number of nodes required, but I've yet to determine whether the added complexity is worth it.
> I'm not deeply committed to the current approach to iteration. But I don't want to switch to something more complicated till I can prove it's a net win.
Paul, this doesn't sound right. Prove that a given change is a net win? Since you obviously can change anything you want at any time, why not go ahead and add the features that seem like they might be worth trying out? See what your users do with them. If the changes/additions turn out to be duds, just rip them out in the next version and let a subset of users whine about it. After all, users will whine either way -- may as well take the path that benefits Arc the most, right?
Short != Clear. Brevity is a false economy, I think you are pushing for the wrong goal.
But perhaps in tune with the entrepreneur ethos?
To say nothing of impatience and hubris.
Even 2 persons should not work together on a language core. The quantity of communication required if 2 persons work on a single language is so large, that hinders and messes up the development process.
The core set of axioms that form a language are almost fundamental as the laws of nature to that language. Just imagine theory of relativity being developed by several scientists together... almost impossible.