[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Var-free programming (slightly off-topic)

On 12/4/01 11:52 AM, "Shriram Krishnamurthi" <sk@cs.brown.edu> wrote:

> Dan,
> I think the connection is only tenuous.  Many of the problems with
> upgrading would persist in the face of linearity.

Indeed it is, but I'm glad you responded with this information; this is
great! Thanks!


> Relating this back to Lightweight Languages: in the early days of our
> JVM, we needed a way to rapidly test its behavior.  Coding in Java is
> painful.  Then David Reiss had a neat insight.  He found out about
> Skij (http://alphaworks.ibm.com/tech/Skij), one of the Scheme's
> written in Java.  As the Skij page points out, "Skij can be easily
> grafted onto an existing Java program to serve as a debugging
> interface to application objects."  So David did just that -- he used
> Skij to drive the execution and upgrading of the VM.  This gave him an
> object inspector, etc, for free.  Whereas sticking to Java would have
> made the whole process painful (and might, consequently, have made us
> test the VM a lot less!), David was on his way in minutes.

I suspect the Python/Jython (nee Jpython) people would cite a similar
experience. I find it interesting to note that many languages implemented
for the JVM start out as lightweight languages that seem focused around
making Java easier to work with in a dynamic, interactive fashion, and then
later, perhaps morph into full language implementations. Skij, and other
"JVM Schemes", like Kawa and Silk come to mind, as well as Jython.

This does show a trend in the larger realm as well, I think: lightweight
languages start out with a specific problem domain, and, if popular and
effective _there_, branch out to cover other realms. To me, Perl is a
canonical example of this effect. However, you rarely see languages designed
to be big "systems" languages, like C++, Java, Common Lisp, Smalltalk, etc.
go in the opposite direction. Does this mean language evolution supports
those which start small and grow larger?

In the case of Perl, I think it definitely headed in that direction, but I
would argue that it's somewhat unmanageable now, with several,
less-than-perfect features bolted on to it's original design. Perl 6 is a
massive rewrite. Similarly, Python is only now getting generators
("continuations lite") and what not, and there's a grand Python rewrite in
it's future as well (Python 3000).

What does this say about lightweight languages and their evolution to more
general realms of programming, as well as big languages and the lack of such
evolution towards problem domains commonly handled by "scripting" languages?

> Lightweight languages rule.

Agreed. Thanks again for your post!

Dan Moniz <dnm@pobox.com> [http://www.pobox.com/~dnm/]