I just want to ask this group are there any other lispers who want to
have Qi http://www.lambdassociates.org/ embedded in lisp, so we could
load Qi and use it like any other lisp library or you prefer the
present solution.
I'm asking this because I want to know do lispers want to see that
happen or I should stop annoying Mark.
thanks
Slobodan
In article
<····································@t1g2000pra.googlegroups.com>,
Slobodan Blazeski <·················@gmail.com> wrote:
> I just want to ask this group are there any other lispers who want to
> have Qi http://www.lambdassociates.org/ embedded in lisp, so we could
> load Qi and use it like any other lisp library or you prefer the
> present solution.
I thought being embedded in CL *was* the present solution.
rg
On Jan 20, 6:56 pm, Ron Garret <·········@flownet.com> wrote:
> In article
> <····································@t1g2000pra.googlegroups.com>,
> Slobodan Blazeski <·················@gmail.com> wrote:
>
> > I just want to ask this group are there any other lispers who want to
> > have Qihttp://www.lambdassociates.org/embedded in lisp, so we could
> > load Qi and use it like any other lisp library or you prefer the
> > present solution.
>
> I thought being embedded in CL *was* the present solution.
>
> rg
Shut up give Gavino.
On 20 Jan, 18:17, Slobodan Blazeski <·················@gmail.com>
wrote:
> On Jan 20, 6:56 pm, Ron Garret <·········@flownet.com> wrote:
>
> > In article
> > <····································@t1g2000pra.googlegroups.com>,
> > Slobodan Blazeski <·················@gmail.com> wrote:
>
> > > I just want to ask this group are there any other lispers who want to
> > > have Qihttp://www.lambdassociates.org/embeddedin lisp, so we could
> > > load Qi and use it like any other lisp library or you prefer the
> > > present solution.
>
> > I thought being embedded in CL *was* the present solution.
>
> > rg
>
> Shut up give Gavino.
I confess I'm puzzled. If you want to use CL with Qi on tap then just
LOAD the following into Qi.
(DEFUN lisp ()
(PROG ()
LOOP
(FORMAT T "~%> ")
(PPRINT (EVAL (READ)))
(GO LOOP)))
Then type (lisp) from Qi and you're in the Lisp top level with easy
access to all of Qi.
Mark
Mark
From: David Golden
Subject: Re: Poll : Are you interested seeing Qi as embedded language in lisp?
Date:
Message-ID: <LqSkj.24220$j7.448818@news.indigo.ie>
Mark Tarver wrote:
> I confess I'm puzzled. If you want to use CL with Qi on tap then just
> LOAD the following into Qi.
>
> (DEFUN lisp ()
> (PROG ()
> LOOP
> (FORMAT T "~%> ")
> (PPRINT (EVAL (READ)))
> (GO LOOP)))
>
> Then type (lisp) from Qi and you're in the Lisp top level with easy
> access to all of Qi.
>
I don't quite get Slobodan's objection so far either, but I'm not sure
that addresses things. I _think_ it _might_ be about the core image
dump Qi installation does. But I think that is ultimately an optional,
not necessary step, in using Qi?* It makes Qi easier/faster to use is
all? (Being linux-based, I do wish you [Mark] had used slightly
different filenames and line endings, but I doubt those are the issues
either, and they don't actually block linux-compat :-) )
(i) using Qi without a custom image dump:
Qi already includes an example of loading and starting Qi in a
non-image-based fashion for allegro - run_fasl_allegro.txt, I don't see
why it wouldn't work on SBCL and other lisp implementations. In fact,
it basically does seem to work fine - I just did it (but I only
checked trivial stuff. And SLIME doesn't really know anything about the
Qi REPL of course - now there's a project for someone more motivated
than me :-)) - just do a
(MAKE-PACKAGE "qi")
(LOAD "Qi 9.1.txt")
(COMPILE-FILE "Qi 9.1.txt")
- now you've got a compiled Qi fasl. Exit SBCL.
When you want to use Qi, enter SBCL and do like it says in
run_fasl_allegro.txt (with the obvious version-dependent substitution)
to load the Qi fasl and start the Qi REPL**
* I don't think it's a good idea to do smalltalk-style image-based
development in lisp (hey, or smalltalk really.), but that's NOT what
Qi's doing, it's just using the common enough image dump strategy as an
optimisation for fast startup and to make Qi look "standalone".
** There is the license-agreement jiggery-pokery too, but it is GPL
anyway, not some dubious click-through EULA, and even so you do
explicitly "agree" to the license (with the setq) in the allegro script.
(ii) packaging:
Now, Qi doesn't have an asdf system definition, but it's a somewhat
different language implemented on top of lisp like Maxima (though
obviously very close to the underlying lisp), not just another lisp
library. That said, I expect it could still be bundled up as an asdf
and asdf-installable system - but (a) the Qi implementation itself is
currently in a single file anyway, you just compile and load it and (b)
what's a user going to do? asdf load the system, which loads that one
file, and just immediately enter the qi repl?. So asdf packaging is of
dubious benefit, unless Slobodan is imagining someone writing
applications in Lisp/Qi and wanting to manage compilation with asdf and
declare package dependencies for asdf-installation... Of course for
Qi applications, Mark _might_ ultimately want a packaging system
written in Qi itself (though I don't speak for him!) for Qi addons
rather than asdf (or asdf augmented with compile/load ops specialised
for .qi files, or something...).
From: Slava Akhmechet
Subject: Re: Poll : Are you interested seeing Qi as embedded language in lisp?
Date:
Message-ID: <87sl0r206h.fsf@gmail.com>
Mark Tarver <··········@ukonline.co.uk> writes:
> I confess I'm puzzled. If you want to use CL with Qi on tap then just
> LOAD the following into Qi.
This isn't related to the thread, but I took your introduction to CS
course in Stony Brook University back in 2001 (or 2002). I remember you
used Qi, and I did the least possible work to get through your class
because it was a "useless class on weird functional stuff". Years of C++
programming do that to you. Oh how much my perspective has changed since
then (both regarding functional programming, and being open to learning
things you don't understand when you happen to get an opportunity)...
Anyway, it is somewhat ironic that a few years later I found myself
running into your work and greatly enjoying much of it (the articles,
ideas behind Qi, etc.) I wanted to mention this for a long time, but
never got to do it until now.
--
Regards,
Slava Akhmechet.
On Jan 21, 2:19 am, David Golden <············@oceanfree.net> wrote:
> Mark Tarver wrote:
> > I confess I'm puzzled. If you want to use CL with Qi on tap then just
> > LOAD the following into Qi.
>
> > (DEFUN lisp ()
> > (PROG ()
> > LOOP
> > (FORMAT T "~%> ")
> > (PPRINT (EVAL (READ)))
> > (GO LOOP)))
>
> > Then type (lisp) from Qi and you're in the Lisp top level with easy
> > access to all of Qi.
>
> I don't quite get Slobodan's objection so far either, but I'm not sure
> that addresses things. I _think_ it _might_ be about the core image
> dump Qi installation does. But I think that is ultimately an optional,
> not necessary step, in using Qi?* It makes Qi easier/faster to use is
> all? (Being linux-based, I do wish you [Mark] had used slightly
> different filenames and line endings, but I doubt those are the issues
> either, and they don't actually block linux-compat :-) )
>
> (i) using Qi without a custom image dump:
>
> Qi already includes an example of loading and starting Qi in a
> non-image-based fashion for allegro - run_fasl_allegro.txt, I don't see
> why it wouldn't work on SBCL and other lisp implementations. In fact,
> it basically does seem to work fine - I just did it (but I only
> checked trivial stuff. And SLIME doesn't really know anything about the
> Qi REPL of course - now there's a project for someone more motivated
> than me :-)) - just do a
>
> (MAKE-PACKAGE "qi")
> (LOAD "Qi 9.1.txt")
> (COMPILE-FILE "Qi 9.1.txt")
>
> - now you've got a compiled Qi fasl. Exit SBCL.
> When you want to use Qi, enter SBCL and do like it says in
> run_fasl_allegro.txt (with the obvious version-dependent substitution)
> to load the Qi fasl and start the Qi REPL**
>
> * I don't think it's a good idea to do smalltalk-style image-based
> development in lisp (hey, or smalltalk really.), but that's NOT what
> Qi's doing, it's just using the common enough image dump strategy as an
> optimisation for fast startup and to make Qi look "standalone".
>
> ** There is the license-agreement jiggery-pokery too, but it is GPL
> anyway, not some dubious click-through EULA, and even so you do
> explicitly "agree" to the license (with the setq) in the allegro script.
>
> (ii) packaging:
>
> Now, Qi doesn't have an asdf system definition, but it's a somewhat
> different language implemented on top of lisp like Maxima (though
> obviously very close to the underlying lisp), not just another lisp
> library. That said, I expect it could still be bundled up as an asdf
> and asdf-installable system - but (a) the Qi implementation itself is
> currently in a single file anyway, you just compile and load it and (b)
> what's a user going to do? asdf load the system, which loads that one
> file, and just immediately enter the qi repl?. So asdf packaging is of
> dubious benefit, unless Slobodan is imagining someone writing
> applications in Lisp/Qi and wanting to manage compilation with asdf and
> declare package dependencies for asdf-installation...
It seems that I failed to explain my thoughts clearly. I want to
program in lisp and just use some Qi functionality when I need it. The
nice comparation is with embedded prolog , like AllegroProlog, or
Paipprolog. If I need some functionality that would be elegantly
implemented in Qi I would use only that, the rest of my programming
will e in lisp . The current system is quite the opposit. It's
something like you code in C++ but you could switch to assembly if you
really want to.
Consider a fallowing example:
father(john,sam).
father(sam,nick).
grandfather(Grandson, Grandfather) :-
father(Grandson,Father),
father(Father,Grandfather).
In embedded prolog (allegro prolog syntax)
;;; This could be typed into standard lisp repl , or saved into
standard .lisp file
(<-- (father john sam))
(<- (father sam nick))
(<-- (grandfather ?grandson ?grandfather)
(father ?grandson ?father)
(father ?father ?grandfather))
Now I could use the functionality of grandfather into my common lisp
code. Takes Bills post about better example http://bc.tech.coop/blog/040919.html
I don't want Qi as image , I want it to be a plain embedded language
as library.
The license seems to be an issue, currently GPL is fine since Qi is
only the compiler, but in my proposition Qi is a yet another library
in the lisp image, so it would GPLize all the other code.
Seems that proposition open a can of worms and there's not much
interest in using Qi this way, so thanks everybody for your answers
I'll look elsewhere and I won't annoy Mark anymore :) .
cheers
Slobodan
On 21 Jan, 09:09, Slobodan Blazeski <·················@gmail.com>
wrote:
> On Jan 21, 2:19 am, David Golden <············@oceanfree.net> wrote:
>
>
>
> > Mark Tarver wrote:
> > > I confess I'm puzzled. If you want to use CL with Qi on tap then just
> > > LOAD the following into Qi.
>
> > > (DEFUN lisp ()
> > > (PROG ()
> > > LOOP
> > > (FORMAT T "~%> ")
> > > (PPRINT (EVAL (READ)))
> > > (GO LOOP)))
>
> > > Then type (lisp) from Qi and you're in the Lisp top level with easy
> > > access to all of Qi.
>
> > I don't quite get Slobodan's objection so far either, but I'm not sure
> > that addresses things. I _think_ it _might_ be about the core image
> > dump Qi installation does. But I think that is ultimately an optional,
> > not necessary step, in using Qi?* It makes Qi easier/faster to use is
> > all? (Being linux-based, I do wish you [Mark] had used slightly
> > different filenames and line endings, but I doubt those are the issues
> > either, and they don't actually block linux-compat :-) )
>
> > (i) using Qi without a custom image dump:
>
> > Qi already includes an example of loading and starting Qi in a
> > non-image-based fashion for allegro - run_fasl_allegro.txt, I don't see
> > why it wouldn't work on SBCL and other lisp implementations. In fact,
> > it basically does seem to work fine - I just did it (but I only
> > checked trivial stuff. And SLIME doesn't really know anything about the
> > Qi REPL of course - now there's a project for someone more motivated
> > than me :-)) - just do a
>
> > (MAKE-PACKAGE "qi")
> > (LOAD "Qi 9.1.txt")
> > (COMPILE-FILE "Qi 9.1.txt")
>
> > - now you've got a compiled Qi fasl. Exit SBCL.
> > When you want to use Qi, enter SBCL and do like it says in
> > run_fasl_allegro.txt (with the obvious version-dependent substitution)
> > to load the Qi fasl and start the Qi REPL**
>
> > * I don't think it's a good idea to do smalltalk-style image-based
> > development in lisp (hey, or smalltalk really.), but that's NOT what
> > Qi's doing, it's just using the common enough image dump strategy as an
> > optimisation for fast startup and to make Qi look "standalone".
>
> > ** There is the license-agreement jiggery-pokery too, but it is GPL
> > anyway, not some dubious click-through EULA, and even so you do
> > explicitly "agree" to the license (with the setq) in the allegro script.
>
> > (ii) packaging:
>
> > Now, Qi doesn't have an asdf system definition, but it's a somewhat
> > different language implemented on top of lisp like Maxima (though
> > obviously very close to the underlying lisp), not just another lisp
> > library. That said, I expect it could still be bundled up as an asdf
> > and asdf-installable system - but (a) the Qi implementation itself is
> > currently in a single file anyway, you just compile and load it and (b)
> > what's a user going to do? asdf load the system, which loads that one
> > file, and just immediately enter the qi repl?. So asdf packaging is of
> > dubious benefit, unless Slobodan is imagining someone writing
> > applications in Lisp/Qi and wanting to manage compilation with asdf and
> > declare package dependencies for asdf-installation...
>
> It seems that I failed to explain my thoughts clearly. I want to
> program in lisp and just use some Qi functionality when I need it. The
> nice comparation is with embedded prolog , like AllegroProlog, or
> Paipprolog. If I need some functionality that would be elegantly
> implemented in Qi I would use only that, the rest of my programming
> will e in lisp . The current system is quite the opposit. It's
> something like you code in C++ but you could switch to assembly if you
> really want to.
> Consider a fallowing example:
> father(john,sam).
> father(sam,nick).
>
> grandfather(Grandson, Grandfather) :-
> father(Grandson,Father),
> father(Father,Grandfather).
> In embedded prolog (allegro prolog syntax)
> ;;; This could be typed into standard lisp repl , or saved into
> standard .lisp file
> (<-- (father john sam))
> (<- (father sam nick))
> (<-- (grandfather ?grandson ?grandfather)
> (father ?grandson ?father)
> (father ?father ?grandfather))
>
> Now I could use the functionality of grandfather into my common lisp
> code. Takes Bills post about better examplehttp://bc.tech.coop/blog/040919.html
> I don't want Qi as image , I want it to be a plain embedded language
> as library.
>
> The license seems to be an issue, currently GPL is fine since Qi is
> only the compiler, but in my proposition Qi is a yet another library
> in the lisp image, so it would GPLize all the other code.
>
> Seems that proposition open a can of worms and there's not much
> interest in using Qi this way, so thanks everybody for your answers
> I'll look elsewhere and I won't annoy Mark anymore :) .
>
> cheers
> Slobodan- Hide quoted text -
>
> - Show quoted text -
> I don't want Qi as image , I want it to be a plain embedded language
> as library.
Change the installation program from
(MAKE-PACKAGE "qi")
(LOAD "Qi 9.1.txt")
(COMPILE-FILE "Qi 9.1.txt")
(DEFUN load-qi-object-code ()
#+CLISP (LOAD "Qi 9.1.fas")
#+(OR ALLEGRO SBCL) (LOAD "Qi 9.1.fasl")
#+CMU (LOAD "Qi 9.1.x86f"))
(load-qi-object-code)
(USE-PACKAGE "qi")
(qi::save)
(FORMAT T "~%Installation finished; hit RETURN.")
(READ-CHAR)
(qi::quit)
to
(MAKE-PACKAGE "qi")
(LOAD "Qi 9.1.txt")
(COMPILE-FILE "Qi 9.1.txt")
(DEFUN load-qi-object-code ()
#+CLISP (LOAD "Qi 9.1.fas")
#+(OR ALLEGRO SBCL) (LOAD "Qi 9.1.fasl")
#+CMU (LOAD "Qi 9.1.x86f"))
(load-qi-object-code)
(USE-PACKAGE "qi")
(FORMAT T "~%Installation finished;")
and you should now have Qi in Lisp sitting in the Lisp toplevel.
Mark
On 21 Jan, 05:54, Slava Akhmechet <·········@gmail.com> wrote:
> Mark Tarver <··········@ukonline.co.uk> writes:
> > I confess I'm puzzled. If you want to use CL with Qi on tap then just
> > LOAD the following into Qi.
>
> This isn't related to the thread, but I took your introduction to CS
> course in Stony Brook University back in 2001 (or 2002). I remember you
> used Qi, and I did the least possible work to get through your class
> because it was a "useless class on weird functional stuff". Years of C++
> programming do that to you. Oh how much my perspective has changed since
> then (both regarding functional programming, and being open to learning
> things you don't understand when you happen to get an opportunity)...
>
> Anyway, it is somewhat ironic that a few years later I found myself
> running into your work and greatly enjoying much of it (the articles,
> ideas behind Qi, etc.) I wanted to mention this for a long time, but
> never got to do it until now.
>
> --
> Regards,
> Slava Akhmechet.
Functional programming has never been very popular amongst CS
students, but the fact you got to appreciate it in the end puts you in
a select minority. Part of the reason it is unpopular is that
students are geared towards vocational learning and FPLs are not seen
as vocational. So mainly what happens is that students get a 1
semester exposure and then forget it ASAP.
At Leeds we had a compulsory ML 1st year course which flopped because
ML was not used anywhere else. Moral: if you want FPLs to stick in a
CS course make sure that their teaching is supported in the rest of
the CS teaching. I'd love to se a CS course that was solidly based on
an inroduction to FPL at year 1.
Oh - ML was dropped from year 1 and replaced by C++. :/
Mark
From: Slava Akhmechet
Subject: Re: unpopularity of FPLs amongst CS students
Date:
Message-ID: <87y7aj589v.fsf@gmail.com>
Mark Tarver <··········@ukonline.co.uk> writes:
> Functional programming has never been very popular amongst CS
> students, but the fact you got to appreciate it in the end puts you in
> a select minority.
The question is whether this will do me any good. The jury is still out
on that one :)
--
Regards,
Slava Akhmechet.
On Jan 21, 7:43 pm, Slava Akhmechet <·········@gmail.com> wrote:
>
> The question is whether this will do me any good. The jury is still out
> on that one :)
What, you're still asking yourself this? FP (or at least Lisp with a
heavy emphasis on FP style) gets the job done.
I suppose you haven't hacked around an imperative mudball of
JavaScript the last few days, like me.
Makes you feel like being a CPU with a bunch of registers.
You should try it. ;P
Leslie
Leslie P. Polzer wrote:
> On Jan 21, 7:43 pm, Slava Akhmechet <·········@gmail.com> wrote:
>
>>The question is whether this will do me any good. The jury is still out
>>on that one :)
>
>
> What, you're still asking yourself this? FP (or at least Lisp with a
> heavy emphasis on FP style) gets the job done.
I think the OP meant he was in the dock, not FP.
> I suppose you haven't hacked around an imperative mudball of
> JavaScript the last few days, like me.
Whoa, j/s is not functional? We had an ILC talk claiming j/s was Lisp a
few years back. I was thinking a port to j/s would be a perfect way to
avoid ever shipping my Algebra software.
kt
--
http://www.theoryyalgebra.com/
"In the morning, hear the Way;
in the evening, die content!"
-- Confucius
Ken Tilton wrote:
> Whoa, j/s is not functional? We had an ILC talk claiming j/s was Lisp a
> few years back.
I remember it.
I still don't agree, but it's definitely more fun than most non-Lisp
languages of similar presence. And firebug (repl, debugger, inspector)
is a not completely rubbish tool for playing with it too
Just don't try to do "traditional OO" designs in it without
understanding how the object system *actually* works. Though I doubt I
need to tell a CLOS user that.
-dan
From: Slava Akhmechet
Subject: Re: unpopularity of FPLs amongst CS students
Date:
Message-ID: <87tzl5k7n2.fsf@gmail.com>
"Leslie P. Polzer" <·············@gmx.net> writes:
>> The question is whether this will do me any good. The jury is still
>> out on that one :)
> What, you're still asking yourself this? FP (or at least Lisp with a
> heavy emphasis on FP style) gets the job done.
I don't question it from the technical point of view (I do, but not in
the traditional sense). The question is more from a practical point of
view. Sometimes getting the technical part of the job done is only 10%
of what needs to be done to make money :)
--
Regards,
Slava Akhmechet.
On Jan 22, 8:00 pm, Slava Akhmechet <·········@gmail.com> wrote:
> I don't question it from the technical point of view (I do, but not in
> the traditional sense). The question is more from a practical point of
> view. Sometimes getting the technical part of the job done is only 10%
> of what needs to be done to make money :)
Yeah, I remember.
"Java - the sellable language"[1]
Leslie
[1] http://www.equi4.com/jcw/files/6a4590706b89c8c2e92ec4626e939696-170.html
Slava Akhmechet <·········@gmail.com> writes:
> Mark Tarver <··········@ukonline.co.uk> writes:
>
>> Functional programming has never been very popular amongst CS
>> students, but the fact you got to appreciate it in the end puts you in
>> a select minority.
> The question is whether this will do me any good. The jury is still out
> on that one :)
Indeed, I believe CS is somewhat similar to music in some regards. You
either do it for your heart and soul or just for the money. I know
quite a few fellow students who follow the thought of "Sex, Drugs,
Computer Science". If something is not usefull, they will refuse to
learn it, no matter how interesting it might be.
--
You made a bad analogy (there are no good ones, but you found a new low)...
-- Ken Tilton