On Apr 30, 9:44 am, Charles Oliver Nutter <[EMAIL PROTECTED]>
wrote:
> Rich Hickey wrote:
>
> > On Apr 30, 2:06 am, Per Bothner <[EMAIL PROTECTED]> wrote:
>
> >> Perhaps a friendly merger might be possible?
>
> > I think peaceful coexistence is more likely. Clojure has certainly
> > ceded the backwards-compatibility ground.
>
> > There was a time (you may not remember) when I was considering either
> > implementing in Kawa or utilizing its infrastructure. But I also
> > wanted to support .Net, so I went off and reinvented a Lisp core in C#/
> > Java. Along the way, I turned Clojure into a functional language, and
> > dropped .Net.
>
> Sounds like there's a story there. As I understand it, Scala's .NET
> support has been mostly abandoned too. Care to elaborate? Was it just
> one too many platforms to support, or were there any technical reasons
> you stuck to the Java side?
>
Clojure was originally written in Common Lisp and generated C#/Java
code. I developed the runtime libraries in Java and hand-ported to C#
as I went. It was tedious, but the differences between C# and Java
were mostly (annoyingly) superficial. However, it was a constant 40%
drain on my time to constantly have to restate everything slightly
differently for MS's behalf.
At some point I decided that, after the core was finished, Clojure
would be growing primarily in libraries, and that there would be found
the greatest set of differences between the platforms. So I guess I
made the opposite decision than did the Fan developers, and decided it
would be better to have libraries deeply leverage a single platform
rather than have everyone that contributed to Clojure have to face the
same 40% porting overhead, never mind all the complexity of
understanding and unifying the semantics of slightly different
infrastructures. It seemed to me one platform would invariably be
preferred, the other the port target, and I might as well just choose
one. Doing so would also allow me to more deeply integrate Clojure
with the type system and library hierarchy of the host platform.
Choosing Java over the CLR was easy. In my opinion:
Java has greater platform reach.
Java is more dynamic. Java's dynamic loading heritage pervades the
platform in many subtle ways.
Java has much more open source activity, many more libraries to
leverage. Java itself becoming open source clinched the deal of it
becoming the open-source target platform of choice.
Java's core data structure library and concurrency stuff is much
better, and its memory model better defined (a big issue once I got
into STM).
Java has a simpler VM architecture, greatly easing interop. Things
like CLR value types and the way they do generics might provide a 10%
perf advantage (or might not), but definitely double the complexity.
Java's generics via erasure are a blessing for dynamic languages.
I eventually decided to generate bytecode on-the-fly and found ASM
much nicer than anything on the CLR side, and, again, a better dynamic
loading story. Differences in bytecode between the platforms are much
bigger than between C#/Java source code, so maintaining a port would
have been much harder still.
Having dropped the CLR, I've never regretted it. Progress on Clojure
proceeded rapidly. I'm very happy with HotSpot, on-the-fly
compilation, library availability, community, portability etc.
Rich
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "JVM
Languages" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/jvm-languages?hl=en
-~----------~----~----~----~------~----~------~--~---
