Popular conceit about learning programming languages

[Pascal Costanza]

Alex Martelli wrote:
> Pascal Costanza wrote:
>    ...
> 
>>(All the scripting languages I have seen so far rely on C for the hairy
>>stuff - and I definitely don't like that. There should be some
>>alternative.)
> 
> 
> There is.  Jython, www.jython.org, is an implementation of the Python 
> language in and for Java -- complete, working, and quite solid.

Ah, yes, of course. But you don't want to suggest that Java is a 
language that is useful for doing hairy and complex stuff. (Sure, most 
things become hairy and complex in Java, but that's a totally different 
story. ;)

I mean, Python is already more advanced than Java.

 > Vyper,
> vyper.sf.net, was a similar project to implement a new dialect of Python in 
> O'Caml (now the project is marked as "no longer active").

Interesting...

 > Python.NET was a
> similar (research) project to implement Python in C#, also now finished.

Oh my goodness. ;)

> Of these, I would only suggest Jython as feasible for production work today.  
> But surely if a third production-level implementation could be added to 
> Classic Python and Jython, this *would* be quite a significant and 
> meaningful accomplishment.
> 
> It's probably important to identify the motivations that would convince 
> somebody to use the hypothetical "LisPython" rather than Common Lisp, 
> Classic Python, or Jython; having a clear target in mind can ease many
> design choices later on.  What are your ideas in the matter?

I must admit that I don't have very clear ideas and detailed plans in 
this regard, only a strange mixture of visions and gut feelings. ;)

As I said before, Python could be a good surface language for Common 
Lisp. Something like Dylan was. The original idea in Lisp was to provide 
the so-called M-expressions one day, but that never turned out to be 
accepted by Lispers. I think the problem with M-expressions or Dylan is 
that these were completely new languages. Choosing an already existing 
language (for example Python) could be the better choice because it is 
already accepted (and proven to work in practice). Of course, that 
language should already be close to Common Lisp, but I don't see any 
major problems in that regard with Python.

Another motivation is as follows: I think the basic idea of .NET (or 
better the CLR) is quite interesting, i.e. to have a common portable 
runtime that can be used by many different languages. However, the 
design of the CLR is still very limited (it is slightly more open than 
the JVM, and that's what Microsoft wants .NET to be compared against, 
although they don't admit it publicly). For example, the CLR has only a 
limited object model that is hard to target from languages that want to 
include interesting features like multiple inheritance or multi-methods.

So in the long run, given that Microsoft really wants to live up to its 
stated goals, the limitations of the CLR need to (and I guess, will) be 
relaxed step by step. If you think this out, you will realize that this 
must end in something that has a similar expressive power as that of 
Lisp. (Here, I am referring to the code=data feature again that would 
ultimately allow you to translate any kind of language.)

So my main vision is to turn Common Lisp into such a kind of common 
runtime for various languages. That's one reason why I started the JVM 
implementation in Common Lisp.

Does this make some sense?


Pascal

P.S.: I know that this sounds like a major undertaking. ;)

-- 
Given any rule, however ‘fundamental’ or ‘necessary’ for science, there 
are always circumstances when it is advisable not only to ignore the 
rule, but to adopt its opposite. - Paul Feyerabend