#define private public - CLR? To Me, That's "Common Lisp Runtime"! (12 Mar 2008)

topic end
<!--
   * Set TOPICTITLE = #define private public - CLR? To Me, That's "Common Lisp Runtime"! (12 Mar 2008)
-->

<style type="text/css">
pre {background-color:#ffeecc;}
</style>

%STARTINCLUDE%
<a name="12"></a>


---+++ [[DefinePrivatePublic20080312DotNetAndLisp][CLR? To me, that's "Common Lisp Runtime"!]] (12 Mar 2008)

<summary>
Alright, so I can no longer keep this to myself. I've been fantasizing about it for too long:
I want a true Common Lisp implementation running on top of, and integrated with,
Microsoft's CLR, and I want it badly.
</summary>

It took a while, but after all those years at [[http://www.cocreate.com][<nop>CoCreate]]
(where we write a lot of Lisp code), I fell in love with
the language. I want to work on projects which use Common Lisp, and I want
the language to be successful and popular in lots of places - if only so that
I have a choice of cool jobs should the need ever arise :D

In other words, I want Common Lisp to become a mainstream language - which it arguably
isn't, even though pretty much everybody agrees about its power and potential.

One way to acquire mainstream super-powers is to team up with one of the 
planet's most potent forces in both software development and marketing: Microsoft. This
is the strategic reason for my proposal. Yes, I know, many Lisp gurus and geeks out 
couldn't care less about Microsoft and the Windows platform, or even shudder at the 
thought. But there are also tactical and technical reasons, so bear with me for a minute 
before you turn on your flamethrowers.

When I say Microsoft, I really mean .NET and its Common <i>Language</i> Runtime. Well, that's
what _they_ say is how to spell out C<i><b>L</b></i>R. But I claim that the L could just
as well stand for Lisp, as the CLR, particularly in conjunction with the
[[http://blogs.msdn.com/hugunin/archive/2007/04/30/a-dynamic-language-runtime-dlr.aspx][Dynamic Language Runtime]] 
extensions which Microsoft is working on, is a suspiciously suitable platform to build an 
implementation of Common Lisp upon: Not only does it provide a renowned garbage collector 
(designed by former Lisp guru 
[[http://channel9.msdn.com/Showpost.aspx?postid=329808][Patrick]] 
[[http://www.international-lisp-conference.org/2005/media/dussud-slides.pdf][Dussud]]) 
and a rich type system, it also has extensive reflection and code generation support, 
and - through the DLR - fast dynamic function calls, 
[[http://listeningtoreason.blogspot.com/2008/02/net-dlr-makes-building-new-language.html][AST processing and compilation]],
debugger integration, REPL support, and all that jazz. It's no coincidence
that languages such as C# and even <nop>VB.NET are picking up new dynamic language
features with every new release, and that Microsoft has even added a new functional
language, F#, to the set of languages which are (or will be)
[[http://www.infoq.com/news/2007/10/FSharp-Plans][fully integrated into Visual Studio]].
The wave is coming in, and we better not miss it!

Best of all, it's not just about Windows anymore: The DLR and <nop>IronPython also
[[http://www.oreillynet.com/xml/blog/2007/05/monodlr_hello_dynamic_language.html][run on top of]]
[[http://www.mono-project.com/][Mono]]. Mono is available for Linux, Solaris, Mac OS X,
various BSD flavors as well as for Windows, so layering Common Lisp on 
top of the CLR doesn't limit us to the Windows platform at all!

Note that I explicitly said "Common Lisp". I think that it's vital
for an implementation on top of the CLR/DLR to be truly standards-compliant. I am not alone
in this belief: In the
[[http://www.ironpython.com/][<nop>IronPython]] and [[http://www.ironruby.net/][<nop>IronRuby]] 
projects, Microsoft went to great lengths to make sure that the implementations are true
to the original language.

What would this buy us?  Well, one recurring and dominant theme in discussions about
the viability of Lisp as a mainstream language is the perceived or real
lack of actively maintained libraries and tools. With the approach I'm outlining,
we could still run all those excellent existing
[[http://www.cl-user.net/asp/tags/software][Common Lisp libraries]] 
and [[http://common-lisp.net/projects.shtml][projects]] 
[[http://www.cliki.net/Library][out]] 
[[http://code.google.com/hosting/search?q=lisp&btn=Search+Projects][there]],
but we'd _also_ be able to use the huge body of code both in the .NET framework
itself and in third-party .NET components. Common Lisp code could seamlessly
call into a library written in, say, C#, and <nop>VB.NET programmers would be able
to consume Common Lisp libraries!

Taking it a little further, we could also integrate with Visual Studio. Where I work,
it would make all the difference in the world if we could edit, run and debug
our Lisp code from within Visual Studio. I'm convinced that this would
attract a large new group of programmers to Common Lisp. Hordes of them, in fact :D

Yes, I know about [[http://common-lisp.net/project/slime/][SLIME]] and
[[http://sourceforge.net/projects/dandelion-ecl][Dandelion]] and
[[http://bitfauna.com/projects/cusp/][Cusp]], and I'm perfectly aware that
[[http://xkcd.com/378/][Emacs]] will simultaneously
iron your shirts, whistle an enchanting tune, convincingly act on your behalf
in today's team phone conference, and book flights to the Caribbean
while compiling, debugging, refactoring and possibly even writing all your
Lisp code for you in the background. Still, there's a whole
caste of programmers who never felt any desire to reach beyond the confines
of the Visual Studio universe, and are perfectly happy with their IDE,
thank you very much. What if we could sell even those programmers on
Common Lisp? (And yes, of course you and I could continue to use our
beloved Emacs.)

Now, all these ideas certainly aren't original. There are a number of projects
out there born out of similar motivation:
   * [[http://www.lsharp.org/][L Sharp .NET]] - a
     Lisp-based scripting language for .NET by Rob Blackwell
   * [[http://yarr.codeplex.com/][Yarr]] - Lisp-based scripting language for .NET
     based on L Sharp
   * [[http://dotlisp.sourceforge.net/dotlisp.htm][<nop>dotLisp]] - a Lisp dialect for .NET,
     written by Rich Hickey (of [[http://clojure.sourceforge.net/][Clojure]] fame)
   * Rich Hickey mentioned in a presentation that the original versions of
     [[http://clojure.sourceforge.net/][Clojure]] were actually written to produce code for the CLR
   * [[http://www.codeplex.com/IronLisp][<nop>IronLisp]] - Lisp on top of the DLR,
     initiated by Llewellyn Pritchard, who later decided to tackle 
     [[http://www.codeplex.com/IronScheme][<nop>IronScheme]] instead
   * There's a even a toy Common Lisp implementation by Microsoft which they shipped
     as a [[http://weblogs.asp.net/rmclaws/archive/2003/10/12/31623.aspx][sample]] in
     the .NET Framework SDK (and now as part of the 
     [[http://www.microsoft.com/downloads/details.aspx?FamilyId=8C09FD61-3F26-4555-AE17-3121B4F51D4D&displaylang=en][Rotor sources]])
   * [[http://funcall.blogspot.com/][Joe Marshall]] has an [[http://jrm-code-project.googlecode.com/svn/trunk/Jrm.Lisp/][interesting project]]
     which looks like Lisp implemented in C#.
   * [[http://sourceforge.net/projects/lispsharp/][<nop>LispSharp]] is a CLR-based
     Lisp compiler (Mirko Benuzzi)
   * [[http://sourceforge.net/projects/clearlisp/][<nop>ClearLisp]] is another
     CL dialect written in C# by Jan Tolenaar.
   * [[http://sourceforge.net/projects/netlisp-script/][A LISP/Scheme language for .NET]] (Adam Milazzo)
   * [[http://sourceforge.net/projects/clearsharp/][<nop>CLearSharp]], by Ola Bini
   * Joe Duffy's [[http://www.bluebytesoftware.com/blog/SearchView.aspx?q=sencha][Sencha]] project
   * [[http://vistasmalltalk.wordpress.com/architectural-overview/][<nop>VistaSmalltalk]] may not _sound_ like
     Lisp, but it actually contains a Lisp engine (implemented in C#), and according to 
     the architecture notes I found, Smalltalk is implemented on top of Lisp.
   * [[http://spookydistance.com/danm_blog/?p=3][<nop>CLinNET]], by Dan Muller
   * [[http://writingcoding.blogspot.com/2007/07/back-from-vacation-and-names.html][<nop>CarbonLisp]], by Eric Rochester
   * [[http://www.meta-alternative.net/techpreview.html][<nop>MBase]], a "metaprogramming framework"
     providing a Lisp-like definition language
   * Sohail Somani [[http://uint32t.blogspot.com/2008/05/lisp-compiler-for-net.html][experiments with .NET IL generation from Lispy syntax]] 
   * [[http://www.weitz.de/rdnzl/][RDNZL]] - .NET interop layer for Common Lisp (Edi Weitz)
   * [[http://foil.sourceforge.net/][FOIL]] - Foreign object interface for Lisp (i.e. an interop layer) on top of both the JVM and the CLR, by Rich Hickey (again!) and Eric Thorsen

Unfortunately, some of those projects are no longer actively maintained,
others implement just a small subset of Common Lisp or even made design decisions
which may conflict with the standard, or they are "merely" interop layers which allow
Common Lisp code to call code written in managed languages, but don't provide
full CLR integration. Don't get me wrong: Most of those projects produced
impressive results - I don't mean to bash any of them, quite to the contrary.

What we learn from this project list is that there are quite a number of
brilliant Lisp hackers out there who are both interested in such a project _and_ capable of
working on it. Most encouraging!

So maybe it isn't just me. Or am I really the only remaining Lisp programmer with such
weird cravings? Be brutally honest with me: Am I a freak?

<i>
PS: I did not explicitly look for them while researching this article, but I know
there are also a number of similar endeavours in the Scheme world, such as
[[http://www.ccs.neu.edu/home/will/Larceny/CommonLarceny/download.html][Common Larceny]],
[[http://www-sop.inria.fr/mimosa/Manuel.Serrano/publi/jot04/jot04.html][<nop>Bigloo.NET]], [[http://www.citeulike.org/group/2570/article/1572558][<nop>Dot-Scheme]] and
[[http://www.kenrawlings.com/pages/Tachy][Tachy]].

PS/2: A few days after posting this article, I found that [[http://ace.roqs.net/?p=101][Toby Jones]]
already coined the term "Common Lisp Runtime" three years ago...
</i>

---

%STOPINCLUDE%

<!--
http://sourceforge.net/projects/liogo/

http://groups.google.com/group/comp.lang.lisp/msg/2b11ecfdc4a15fb4

http://weblogs.asp.net/astopford/archive/2007/09/03/ironlisp-mop-and-more.aspx

http://listeningtoreason.blogspot.com/2008/02/net-dlr-makes-building-new-language.html

http://www.codeproject.com/KB/recipes/Irony.aspx
-->

%COMMENT{type="below" nonotify="on"}%

---
to top
End of topic
Skip to action links | Back to top
You are here: Blog > DefinePrivatePublic20080312DotNetAndLisp

r1.20 - 17 Mar 2009 - 15:51 - ClausBrod to top
Blog