I have just spent the past few days exploring the Joy language.
http://www.latrobe.edu.au/philosophy/phimvt/joy.html
I wrote an interpreter for it in Lisp. (if anyone wants a copy just
e-mail me). Joy takes direct advantage of list consing at runtime to
produce composite subroutines from elemental subroutines --
programming by operating on functions. Functions in joy are little
more than quoted lists of tokens.
But this experience has spawned a number of questions for us as Lisp
programmers...
I have seen mentioned elsewhere in this list that some feel that Dylan
is not as dynamic as the language would claim. Indeed, my own
experience has been that I want to get as much early binding in Dylan
as possible for the sake of runtime speed. There are only a few rare
instances where I took advantage of Dylan's dynamic capabilities.
At the same time, it has often been claimed as one of Lisp's strong
points, that the structure of the executable language and that of data
are so similar that one can view code as data and vice versa. But
aside from macrology, are there any examples where this duality
between code and data are utilized? It would also seem that once
functions have been compiled to native code, one looses this aspect of
Lisp.
- DM
David McClain wrote:
> But
> aside from macrology, are there any examples where this duality
> between code and data are utilized?
For one, it lets a standalone Lisp app be configured at run-time with
code, not just data. That is huge. With data you hope you have enough
parameters and have coded for enough values of those parameters always
to be able to get the behavior you want. With code you can get a lot
more out of a given app.
> It would also seem that once
> functions have been compiled to native code, one looses this aspect of
> Lisp.
The code being treated as data travels around as source until read and
evaled or compiled on the fly.
kenny
clinisys
In article <····························@posting.google.com>,
·········@mindspring.com (David McClain) wrote:
> I have just spent the past few days exploring the Joy language.
>
> http://www.latrobe.edu.au/philosophy/phimvt/joy.html
>
> I wrote an interpreter for it in Lisp. (if anyone wants a copy just
> e-mail me). Joy takes direct advantage of list consing at runtime to
> produce composite subroutines from elemental subroutines --
> programming by operating on functions. Functions in joy are little
> more than quoted lists of tokens.
Having just read the top level page and about half of the tutorial, it
looks to me as if Joy could be easily implemented as a short library in
PostScript (but not in FORTH).
> I have seen mentioned elsewhere in this list that some feel that Dylan
> is not as dynamic as the language would claim. Indeed, my own
> experience has been that I want to get as much early binding in Dylan
> as possible for the sake of runtime speed. There are only a few rare
> instances where I took advantage of Dylan's dynamic capabilities.
Isn't that a description of your needs rather than of the language? And
haven't you in fact moved mostly to using even more static languages
e.g. OCaml?
-- Bruce
"Bruce Hoult" <·····@hoult.org> wrote in message
································@news.paradise.net.nz...
> In article <····························@posting.google.com>,
> ·········@mindspring.com (David McClain) wrote:
>
> > I have just spent the past few days exploring the Joy language.
> >
> > http://www.latrobe.edu.au/philosophy/phimvt/joy.html
> >
> > I wrote an interpreter for it in Lisp. (if anyone wants a copy just
> > e-mail me). Joy takes direct advantage of list consing at runtime to
> > produce composite subroutines from elemental subroutines --
> > programming by operating on functions. Functions in joy are little
> > more than quoted lists of tokens.
>
> Having just read the top level page and about half of the tutorial, it
> looks to me as if Joy could be easily implemented as a short library in
> PostScript (but not in FORTH).
I am not expert enough in PostScript to know the answer to this question.
But it was certainly very easy to define a near-Joy language in Lisp.
> > I have seen mentioned elsewhere in this list that some feel that Dylan
> > is not as dynamic as the language would claim. Indeed, my own
> > experience has been that I want to get as much early binding in Dylan
> > as possible for the sake of runtime speed. There are only a few rare
> > instances where I took advantage of Dylan's dynamic capabilities.
>
> Isn't that a description of your needs rather than of the language? And
> haven't you in fact moved mostly to using even more static languages
> e.g. OCaml?
Yes, I thought of that after I sent the message. This character of Dylan was
exercised to suit my particular needs. I generally compile stand-alone
applications, and I have always wondered what it would be like to invoke
dynamism in such a program.
And yes, I write a lot of OCaml, but I write a lot of other languages too.
Mostly NML, Mathematica, and Lisp, followed secondarily by OCaml, C/C++, and
then trailed distantly by other more exotic languages. I enjoy the issue of
human-computer interaction, especially with regard to accurate specification
of human questions/problems to computer code. I have spent so much of my
life making programming mistakes and so I am always searching for better
ways to express myself on a computer.
- DM