Hello,
I need a free(as in beer) Lisp implementation with the following caracteristics:
1. Runs on Windows and Linux.
2. Can access a MySql database.
Ideal would be if it also could access Java like Kawa(a Scheme implementation).
Thanks for any feedback...
·········@gmx.net (thelifter) writes:
> Hello,
>
> I need a free(as in beer) Lisp implementation with the following
> caracteristics:
>
> 1. Runs on Windows and Linux.
> 2. Can access a MySql database.
>
> Ideal would be if it also could access Java like Kawa(a Scheme
> implementation).
>
> Thanks for any feedback...
______
/ \
.' PLEASE `.
| DO NOT | _____
| FEED THE | ,'.....`.
`. TROLLS ,' ,'........ )
\_ _/ |........ ,'
| | `. .... _/
| | ,'.,'-'
| | /../
| | ,'.,'
| | /../
. | | /..'
.\_\| |/_/,
___ | | ___
. `--' .
See
<http://groups.google.com/groups?threadm=b295356a.0208011247.562f2f26%40posting.google.com>
for an example.
Edi Weitz <···@agharta.de> writes:
>> I need a free(as in beer) Lisp implementation with the following
>> caracteristics:
>>
>> 1. Runs on Windows and Linux.
>> 2. Can access a MySql database.
>>
>> Ideal would be if it also could access Java like Kawa(a Scheme
>> implementation).
>>
>> Thanks for any feedback...
[snip]
> .' PLEASE `.
> | DO NOT | _____
> | FEED THE | ,'.....`.
> `. TROLLS ,' ,'........ )
[snip]
> See
> <http://groups.google.com/groups?threadm=b295356a.0208011247.562f2f26%40posting.google.com>
> for an example.
What do your waste-of-space anti-troll "art" and that google-group pointer
have to do with a request for a scheme implementation?
I'm also only new in either scheme and/or lisp worlds and generally lurking
on these groups; however, when starting out I also have a small notional
shopping-list of things I require in a language and implementation, quite
similar to the above.
Your shitty response has just earned you a free push of the `k' button in
Gnus.
~Tim
--
Not every discomfort should ·······@stirfried.vegetable.org.uk
be criminalised. (Bill Unruh) |http://spodzone.org.uk/
From: Tim Daly, Jr.
Subject: Re: Need free/portable Lisp with Database access
Date:
Message-ID: <87he9opwh5.fsf@tenkan.org>
Tim Haynes <···············@stirfried.vegetable.org.uk> writes:
[snip]
> [snip]
>
> > See
> > <http://groups.google.com/groups?threadm=b295356a.0208011247.562f2f26%40posting.google.com>
> > for an example.
>
> What do your waste-of-space anti-troll "art" and that google-group pointer
> have to do with a request for a scheme implementation?
>
> I'm also only new in either scheme and/or lisp worlds and generally lurking
> on these groups; however, when starting out I also have a small notional
> shopping-list of things I require in a language and implementation, quite
> similar to the above.
> Your shitty response has just earned you a free push of the `k' button in
> Gnus.
You certainly seem new. I don't think you followed the link, and read
what was there. Give it a shot, and then consider apologizing to Edi,
a valuable member of the Lisp community, who was apparently trying to
prevent one of the prolonged flame sessions that plague this forum.
Rhetorically - in what sense can a few lines of ASCII constitute a
waste of space these days?
For the benefit of people who _aren't_ pretending not to know the
answer : CLISP is free, runs on Windows and Linux, and you can access
a MySQL database with it. If you want a Scheme, Bigloo is free, runs
on Windows and Linux, and you can access a MySQL database with it,
too.
-Tim
--
···@tenkan.org (Tim Daly, Jr.) writes:
>> I'm also only new in either scheme and/or lisp worlds and generally lurking
>> on these groups; however, when starting out I also have a small notional
>> shopping-list of things I require in a language and implementation, quite
>> similar to the above.
>> Your shitty response has just earned you a free push of the `k' button in
>> Gnus.
>
> You certainly seem new.
That's logical, since I said so. These things are also relative.
> I don't think you followed the link, and read what was there.
You think wrong.
> Give it a shot, and then consider apologizing to Edi, a valuable member
> of the Lisp community, who was apparently trying to prevent one of the
> prolonged flame sessions that plague this forum.
Considered, and, given that the post to which I followed-up bore no
resemblance to a plain statement of fact and every resemblance to an
unhelpful attempt to blast a newbie off into space, rejected.
> Rhetorically - in what sense can a few lines of ASCII constitute a
> waste of space these days?
Rhetorically - ever since I had to read down through them in a finite
terminal height, I think.
> For the benefit of people who _aren't_ pretending not to know the answer
> : CLISP is free, runs on Windows and Linux, and you can access a MySQL
> database with it. If you want a Scheme, Bigloo is free, runs on Windows
> and Linux, and you can access a MySQL database with it, too.
That is a more useful pointer. I *have* spent some (little) time looking
around through various lisps and schemes, and have settled on no fixed one
for multiple-unix lots-of-external-libraries/apis/modules purposes. Yet.
~Tim
--
And in the rapture and the charm, ·······@stirfried.vegetable.org.uk
Came the tranquil and the calm, |http://spodzone.org.uk/
On the ridge of the mighty Atlantic. |
A long time ago, in a galaxy far, far away, Tim Haynes <···············@stirfried.vegetable.org.uk> wrote:
>> For the benefit of people who _aren't_ pretending not to know the answer
>> : CLISP is free, runs on Windows and Linux, and you can access a MySQL
>> database with it. If you want a Scheme, Bigloo is free, runs on Windows
>> and Linux, and you can access a MySQL database with it, too.
>
> That is a more useful pointer. I *have* spent some (little) time looking
> around through various lisps and schemes, and have settled on no fixed one
> for multiple-unix lots-of-external-libraries/apis/modules purposes. Yet.
The problem is that there are no answers that are likely to scale
terribly far beyond "toying around."
CLISP is free, and plays well enough on Unix and Windows, but has the
huge demerit that it is rather painful to add additional APIs to it in
any fashion that you'd hope would be portable.
I'm sure you can get something quasi-working with CLISP that would be
quasi-portable; I would NOT be confident that it would scale nicely if
you wanted to expand your use to Do Tough Stuff.
I'd feel slightly more confident about the interfaces for CMU/CL that
talk to PostgreSQL, but that has the dual demerits that:
a) You asked for MySQL, and
b) CMU/CL is really "Unix-only."
I think you'd be a lot better off if you dropped the "must be portable
to Unix and Windows" requirement; that would open up a LOT of choices,
in that you no longer get forced into trying to find an API that
functions, compiles, and links identically on Windows and Unix.
Here's an "API" that might even run on both CMU/CL and CLISP, that I
have used to communicate with PostgreSQL on Unix. It wouldn't be too
difficult to spruce it up to build confidence that it works with
multiple DBMSes and multiple CL implementations, although that
requires dropping ANY attempt at feigning support for Windows.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun name-temp-file ()
(let ((rval (random 250))
(now (get-universal-time)))
(format nil "sql-~D.~D" now rval)))
(defun build-query-command-name (rfilename)
(concatenate 'string
"/usr/bin/psql -A < /tmp/" rfilename))
(defun set-up-query (query)
(let* ((tmpfilename (name-temp-file))
(command (build-query-command-name tmpfilename))
(querypath (make-pathname :directory '(:absolute "tmp")
:name tmpfilename))
(result nil))
(with-open-file
(s querypath :direction :output)
(format s "~A~%" query))
(with-open-stream
(st (common-lisp-user::run-shell-command command :output :stream))
(setf result
(process-sql-query st)))
(delete-file querypath)
result))
(defun process-sql-query (stream)
(let ((headers nil)
(rows '())
(first-line (read-line stream nil nil)))
(setf headers (split-on-bar first-line))
(loop for line = (read-line stream nil nil)
while line
do
(if line
(setf rows (cons (split-on-bar line) rows))))
(list headers (rest rows))))
(defun split-on-bar (rawline)
(let ((result nil))
(loop
with line = (concatenate 'string rawline "|")
with length = (length line)
and pos = 0
for nextbar = (search "|" line :start2 pos)
while nextbar
for element = (subseq line pos nextbar)
collect element into result-list
do
(setf pos (+ 1 nextbar))
finally (loop
with results = result-list
with array = (setf result (make-array
(list (length results))))
for i = 0 then (incf i)
for value in results
do (setf (aref result i) value)
finally array))
result))
(defun lookup-field (field header record)
(let ((pos (position field header :test 'equal)))
(aref record pos)))
(defun open-sql-connection ()
(common-lisp-user::run-shell-command "/usr/bin/psql" :input :stream))
(defun begin-transaction (connection)
(format connection "begin work;~%"))
(defun commit-transaction (connection)
(format connection "commit work;~%"))
(defun search-field (field result s)
(lookup-field field (first result) s))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
--
output = ("cbbrowne" ·@cbbrowne.com")
http://cbbrowne.com/info/lisp.html
"On the other hand, O'Reilly's book about running W95 has a toad as
the cover animal. Makes sense; both have lots of warts and croak all
the time." --- Michael Kagalenko,
Christopher Browne <········@acm.org> writes:
>> That is a more useful pointer. I *have* spent some (little) time looking
>> around through various lisps and schemes, and have settled on no fixed
>> one for multiple-unix lots-of-external-libraries/apis/modules purposes.
>> Yet.
>
> The problem is that there are no answers that are likely to scale
> terribly far beyond "toying around."
Hmmm.
> CLISP is free, and plays well enough on Unix and Windows, but has the
> huge demerit that it is rather painful to add additional APIs to it in
> any fashion that you'd hope would be portable.
This could well be a problem.
FWIW, I exist in two capacities:
a) there's me, I've got a little website which uses librep in a couple of
CGIs, and wouldn't mind having a few more at some stage. PostgreSQL
backend (but not from librep, not yet - but I want to hook those
together at some stage). If I'm going to include any CL instead, it has
to be a Free implementation and build on linux and NetBSD.
b) I work vaguely in the development department at work - not a programmer,
but I see a lot of {} characters going past every day - to say nothing
of <> - and idly wonder if it wouldn't be better with more () as well.
(Give it a few decades for anything to make its way through.) Databases
are involved by the ton.
> I'm sure you can get something quasi-working with CLISP that would be
> quasi-portable; I would NOT be confident that it would scale nicely if
> you wanted to expand your use to Do Tough Stuff.
Right, that's a useful datapoint to keep in mind. Thanks.
> I'd feel slightly more confident about the interfaces for CMU/CL that
> talk to PostgreSQL, but that has the dual demerits that:
> a) You asked for MySQL, and
*I* didn't, at least not explicitly, and personally I can't abide the silly
little thing, for all the normal reasons starting with '``' and working up.
I've been fond of combining Ruby, DBI, PostgreSQL and Sablotron (the xslt
processor) before now. Ork demands ODBC abilities somewhere. The net result
is that a `generic database backend, like DBI' is appealing.
> b) CMU/CL is really "Unix-only."
For me, that's not a major problem. For ork, it definitely is.
> Here's an "API" that might even run on both CMU/CL and CLISP, that I have
> used to communicate with PostgreSQL on Unix. It wouldn't be too difficult
> to spruce it up to build confidence that it works with multiple DBMSes
> and multiple CL implementations, although that requires dropping ANY
> attempt at feigning support for Windows.
>
> ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
> (defun name-temp-file ()
> (let ((rval (random 250))
[snip]
> (defun open-sql-connection ()
> (common-lisp-user::run-shell-command "/usr/bin/psql" :input :stream))
>
> (defun begin-transaction (connection)
> (format connection "begin work;~%"))
[snip]
OK, I see what it's doing. I'll have to investigate interfacing to C and
back though, ultimately.
Thanks a lot for the response - I stumbled across one or two useful sites
about clisp and/or cmucl and/or postgresql backends before now, but keep
running into build or portability or support problems. I'll just keep on
plodding until it all comes together :)
~Tim
--
20:52:18 up 8 days, 20:30, 7 users, load average: 1.28, 0.93, 0.48
······@stirfried.vegetable.org.uk |The night skips the sleeping years
http://piglet.is.dreaming.org |And re-awakes the memory
Oops! Tim Haynes <···············@stirfried.vegetable.org.uk> was seen spray-painting on a wall:
> Christopher Browne <········@acm.org> writes:
>> Here's an "API" that might even run on both CMU/CL and CLISP, that I have
>> used to communicate with PostgreSQL on Unix. It wouldn't be too difficult
>> to spruce it up to build confidence that it works with multiple DBMSes
>> and multiple CL implementations, although that requires dropping ANY
>> attempt at feigning support for Windows.
>>
>> ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
>> (defun name-temp-file ()
>> (let ((rval (random 250))
> [snip]
>> (defun open-sql-connection ()
>> (common-lisp-user::run-shell-command "/usr/bin/psql" :input :stream))
>>
>> (defun begin-transaction (connection)
>> (format connection "begin work;~%"))
> [snip]
>
> OK, I see what it's doing. I'll have to investigate interfacing to C and
> back though, ultimately.
The problem with that approach is that the libraries and compilers
that you have to talk to are liable to be quite different between Unix
and Windows.
The approach I outlined above involved talking to the DBMS via a pipe,
which is certainly reasonable on *nix; the "idiomatic" way to
communicate with other processes on *doze involves calling COM
objects, which is so different that it makes it rather difficult to
build portable ways to do this sort of thing.
It would likely make more sense to have a *nix "back end" that does
"Unixy things" that publishes a CL interface, and have a *doze "back
end" using COM and such that publishes the same CL interface. That
may well be how the commercial Lisp vendors do it, and allows both
kinds of systems to "talk nice" in their respective fashions. It
makes for a pile of non-portable code somewhere. And I haven't seen
anything like that on the "gratis" side.
--
If this was helpful, <http://svcs.affero.net/rm.php?r=cbbrowne> rate me
http://www3.sympatico.ca/cbbrowne/lisp.html
"The beginning of wisdom for a [software engineer] is to recognize the
difference between getting a program to work, and getting it right."
-- M A Jackson, 1975
Christopher Browne <········@acm.org> wrote:
+---------------
| CLISP is free, and plays well enough on Unix and Windows, but has the
| huge demerit that it is rather painful to add additional APIs to it in
| any fashion that you'd hope would be portable.
|
| I'm sure you can get something quasi-working with CLISP that would be
| quasi-portable; I would NOT be confident that it would scale nicely if
| you wanted to expand your use to Do Tough Stuff.
|
| I'd feel slightly more confident about the interfaces for CMU/CL that
| talk to PostgreSQL, but that has the dual demerits that:
| a) You asked for MySQL, and
| b) CMU/CL is really "Unix-only."
+---------------
The real enabler here would be using PostgreSQL instead of MySQL[1], since
Eric Marsden's "pg.lisp" (see <URL:http://www.chez.com/emarsden/downloads/>)
works very nicely in both CMUCL & CLISP, and is pure Lisp code -- no FFI
hackery needed. [Though it does have a couple of feature tests in it here
and there to address various CL implementation oddities and to access the
non-standard but nearly-universal socket APIs...]
-Rob
[1] Some would encourage you to use PostgreSQL instead of MySQL *anyway*,
for reasons having nothing to do with Lisp, but that's verging towards
being off-topic (and potentially inciting a flame war) so let's just
leave it at that.
-----
Rob Warnock, PP-ASEL-IA <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
After a long battle with technology,····@rpw3.org (Rob Warnock), an earthling, wrote:
> [1] Some would encourage you to use PostgreSQL instead of MySQL *anyway*,
> for reasons having nothing to do with Lisp, but that's verging towards
> being off-topic (and potentially inciting a flame war) so let's just
> leave it at that.
The following is to soon be presented by, um, my boss...
<http://conferences.oreillynet.com/cs/os2003/view/e_sess/4035>
The fact that the commercial world is starting to see PostgreSQL as
having some actual merit has a fair bit to with the specific DB
instances I work with, day to day...
Since the O.P. specifically asked about MySQL, I chose not to make
comments about "mommas wearing army boots" or "just a toy" or such;
that's just going to irritate people, to no value...
--
output = ("aa454" ·@freenet.carleton.ca")
http://cbbrowne.com/info/multiplexor.html
Marriage means commitment. Of course, so does insanity.
Christopher Browne <········@acm.org> writes:
> CLISP is free, and plays well enough on Unix and Windows, but has the
> huge demerit that it is rather painful to add additional APIs to it in
> any fashion that you'd hope would be portable.
Can you please elaborate on that? I have trouble understanding what
you mean.
CLISP has so-called external modules, which allows to add Lisp-visible
functions or whatever written in (typically) C and to access Lisp
objects from there.
In particular, this module concept is highly portable, much more
portable than the FFI. You can extend CLISP and compile modules on
*every* platform that CLISP runs on. That seems highly portable to me.
As an example, last year I showed in the clisp-user list how to add
the regexp module, which is part of the source distribution, to
MS-Windows ports of CLISP. Up to then, it had only been compiled on
UNIX boxes, why I don't know.
I wrote an article last year on extending CLISP with external modules.
In summary, getting a postgres or mysql interface to work with CLISP
on both MS-Windows and all supported flavours of UNIX is more a
problem of seeing whether the C mysql/postgres libraries look similar
on MS-Windows and UNIX than it is a problem of "portability" with
CLISP.
> I'm sure you can get something quasi-working with CLISP that would be
> quasi-portable; I would NOT be confident that it would scale nicely if
> you wanted to expand your use to Do Tough Stuff.
Again, what do you mean?
Lack of a unified way to access SQL databases?
Are you calling for a port of "Uncommon SQL" to CLISP (I don't know
whether it already exists)?
I have heard rumours that John K. Hinsdale, who wrote an Oracle DB
module for CLISP, is working on a unified-for-CLISP Lisp-level API for
Oracle, postgres and mysql.
What does "quasi-working with CLISP" mean?
> I'd feel slightly more confident about the interfaces for CMU/CL that
> talk to PostgreSQL, but that has the dual demerits that:
> Here's an "API" that might even run on both CMU/CL and CLISP, that I
> have used to communicate with PostgreSQL on Unix.
[snipped code using a one-way pipe to a "psql" program]
> requires dropping ANY attempt at feigning support for Windows.
CLISP's MAKE-PIPE-INPUT/OUTPUT-STREAM also works on MS-Windows. So
support for that plattform reduces to "is the psql client program
available on MS-Windows"? It's not at all a CLISP question. E.g. The
MS-Windows 2k box here in front of me has a osql.exe, with which I can
access MSDE or MS-SQL-Server databases. I could use it to send DB
queries via pipes much like your psql example.
On "toy" vs. non-toy: If I understand your code correctly, you fork
an external /usr/bin/psql program for every query to the DB. That
qualifies as "toy", "quasi-working" or "not to expand to do tough
stuff" in my eyes. It must, by nature, be much less efficient than
e.g. John Hinsdale's Oracle module or the postgres module that has
been distributed with CLISP for many years.
If there were 2-3 more clones of myself, we'd spit out such CLISP
modules for any DB you present to me, UNIX and MS-Windows, with
identical APIs at Lisp-level.
Christopher, pardon my tone if you feel it's offensive. It's not
supposed to be. Informative it ought to be.
Regards,
Jorg Hohle
Tim Daly, Jr. <···@tenkan.org> wrote:
> For the benefit of people who _aren't_ pretending not to know the
> answer : CLISP is free, runs on Windows and Linux, and you can access
> a MySQL database with it. If you want a Scheme, Bigloo is free, runs
> on Windows and Linux, and you can access a MySQL database with it,
> too.
PLT-Scheme is also free, runs on GNU/Linux and Windows (and possible
Mac, I think), and you can access MySQL and PostgreSQL databases with it,
as well as anything that speaks ODBC, either at a low level, or through
schemeql. Hopefully we'll start to see those interfaces standardise RSN.
--
MJR http://mjr.towers.org.uk/ IM: ····@jabber.at
This is my home web site. This for Jabber Messaging.
How's my writing? Let me know via any of my contact details.
Tim Haynes <···············@stirfried.vegetable.org.uk> writes:
> What do your waste-of-space anti-troll "art" and that google-group
> pointer have to do with a request for a scheme implementation?
It means that you shouldn't bother to respond to anything
posted by "thelifter".
> I'm also only new in either scheme and/or lisp worlds and generally
> lurking on these groups; however, when starting out I also have a
> small notional shopping-list of things I require in a language and
> implementation, quite similar to the above.
If you have questions, you should ask them yourself. You
definitely should not expect the regulars of comp.lang.lisp to provide
much response to anything posted by "thelifter".
> Your shitty response has just earned you a free push of the `k'
> button in Gnus.
That keypress probably doesn't do what you think (hint: it
doesn't add a poster to your killfile).
--
Raymond Wiker Mail: ·············@fast.no
Senior Software Engineer Web: http://www.fast.no/
Fast Search & Transfer ASA Phone: +47 23 01 11 60
P.O. Box 1677 Vika Fax: +47 35 54 87 99
NO-0120 Oslo, NORWAY Mob: +47 48 01 11 60
Try FAST Search: http://alltheweb.com/
Raymond Wiker <·············@fast.no> writes:
> Tim Haynes <···············@stirfried.vegetable.org.uk> writes:
>
>> What do your waste-of-space anti-troll "art" and that google-group
>> pointer have to do with a request for a scheme implementation?
>
> It means that you shouldn't bother to respond to anything
> posted by "thelifter".
Ah. So why didn't it say so?
>> Your shitty response has just earned you a free push of the `k'
>> button in Gnus.
>
> That keypress probably doesn't do what you think (hint: it
> doesn't add a poster to your killfile).
It does exactly what I know it does on here. (Hint: I didn't say it
killfiled anyone.)
~Tim
--
17:10:35 up 8 days, 16:48, 7 users, load average: 0.14, 0.11, 0.09
······@stirfried.vegetable.org.uk |And your radiance shines
http://piglet.is.dreaming.org |Like the moon of all innocent grace
Tim Haynes <···············@stirfried.vegetable.org.uk> writes:
> Raymond Wiker <·············@fast.no> writes:
>
> > Tim Haynes <···············@stirfried.vegetable.org.uk> writes:
> >
> >> What do your waste-of-space anti-troll "art" and that google-group
> >> pointer have to do with a request for a scheme implementation?
> >
> > It means that you shouldn't bother to respond to anything
> > posted by "thelifter".
>
> Ah. So why didn't it say so?
The text on the sign (which you even copied in your post) said
"do not feed the trolls".
>
> >> Your shitty response has just earned you a free push of the `k'
> >> button in Gnus.
> >
> > That keypress probably doesn't do what you think (hint: it
> > doesn't add a poster to your killfile).
>
> It does exactly what I know it does on here. (Hint: I didn't say it
> killfiled anyone.)
Well, the effect of k is to kill the current thread... not a
particularly effective measure, as you were already at the end of the
thread.
--
Raymond Wiker Mail: ·············@fast.no
Senior Software Engineer Web: http://www.fast.no/
Fast Search & Transfer ASA Phone: +47 23 01 11 60
P.O. Box 1677 Vika Fax: +47 35 54 87 99
NO-0120 Oslo, NORWAY Mob: +47 48 01 11 60
Try FAST Search: http://alltheweb.com/
Raymond Wiker <·············@fast.no> writes:
>> > That keypress probably doesn't do what you think (hint: it
>> > doesn't add a poster to your killfile).
>>
>> It does exactly what I know it does on here. (Hint: I didn't say it
>> killfiled anyone.)
>
> Well, the effect of k is to kill the current thread... not a
> particularly effective measure, as you were already at the end of the
> thread.
That leaves negative-score ticks beside the affected article(s) for
inclusion into the adaptive scoring. This is exactly what I intended ;)
~Tim
--
We stood in the moonlight ·······@stirfried.vegetable.org.uk
and the river flowed |http://spodzone.org.uk/
I'm answering to my own posting because I want to sum up several
responses to different individuals:
First I would like to answer to the technical postings.
Christopher Browne suggested using Clisp for accessing MySql, but I
tried using it and I
saw no way to do it in a simple portable manner. There is no package
for Clisp
that allows it, at least non that I'm aware of. I didn't read every
line
of code you posted but if I understood correctly you are basically
calling
a subprocess to query the database and parsing the output from that
process, right?
This is the same that emacs sql-mode does, it doesn't parse the output
though but
only prints it on the screen.
This is not exactly what I want. I want a real database driver, if you
know
what I mean.
Now I also remember Paul Graham
who used Clisp in his famous program that became Yahoo shopping,
stating
that he used the Unix filesystem to store the data. I realize that his
choice
was also motivated by necessity :)
Can anyone say something about GCL? Does it allow database access in a
portable
(windows and linux) manner?
Second, now comes the part that I would better like to omit, but I
feel compelled
to waste my time...
Since I lurk in this group for some while and have read a LOT of
archived articles from it, I was somewhat used to the rough tone of
some of the inhabitants.
Nevertheless the answer I received flabbergasted me, especially
considering it came from a knowledgeable person, like Edi Weitz.
Asking myself how I could explain this kind of behaviour I searched
the archives
about postings from Edi Weitz containing the word "Troll":
http://groups.google.com/groups?as_q=troll&safe=images&ie=UTF-8&oe=UTF-8&as_uauthors=edi%40agharta.de%20&lr=&hl=en
There are not many, but from the results it seems clear that Edi likes
to accuse
others of trolling, this seems to be like a sport among some here.
There is another person here who also likes to share negative comments
about others
and his name is Erik Naggum. If you want to find out more about him go
to the
following link or search for his postings on news.google.com:
http://groups.google.com/groups?hl=en&lr=&ie=UTF-8&oe=UTF-8&threadm=37E86F61.65BE56DA%40mindless.com&rnum=31&prev=/groups%3Fq%3Derik%2Bnaggum%2Bfaq%2Bgroup:comp.lang.lisp%26hl%3Den%26lr%3D%26ie%3DUTF-8%26oe%3DUTF-8%26start%3D30%26sa%3DN
Sorry Erik for mentioning your name, but I needed to do this because I
feel the
need for composing a new expression for lack of an existing one(you
might
consider this a bottom up language construction not unlike what Lisp
offers).
This new expression I want to create is "Erik-Naggunism".
So what does Erik-Naggunism mean? I would describe Erik-Naggunism in
simple words
as the characteristic of persons like Erik Naggum, which is a
combination of:
a) Knowledgeable and intelligent
b) Unfriendly and arrogant.
So Erik-Naggunism is like a disease that is spreading in c.l.l. beware
of it!
Now back to Edi Weitz, I could write a lot to you, but I will try to
be concise,
I don't want to waste more time on this than I already did.
I followed your link to one of my old postings. Let me quote one part
of it:
"I agree that Lisp is probably one of the best languages around if not
the best. "
Basically the article was about asking for a free Lisp compiler that
generates efficient code.
And you call me a troll?
In fact, before you start discussing my old article lets stop it right
here. Why?
Because it doesn't matter. What matters it the question I posted in
this thread,
which was sincere believe me or not.
You probably didn't even notice that when considering my old postings
you where
argumenting ad hominem. Your answer was not dictated by the question
but by what I posted in the past, by the conclusions you made about me
from past experience.
This is called ad hominem. Edi, now answer me, how would you call a
person
that arguments ad hominem?
You probably didn't think about the fact that other people might also
have an interest in that particular question, eithe now or in the
future when googling
the archives.
Lisp enthusiasts probably wonder all the time why other language users
can't
think rationally and come to the conclusion that Lisp is a superior
language.
But, when reading the answers to my simple question can you honestly
say that
the people in this newsgroup are rational? How do they expect others
to be rational in their language choice?
Finally, isn't c.l.l supposed to be a place where people can seek
answers for
questions regarding Lisp? Is this the user community you expect
newcomers to
enjoy? Is this what will spread the use of Lisp? Just compare the
signal to noise
ration and you will see that most answers to my postings had nothing
to do
with my questions.
Unfortunately the same applies to my own posting. Most what I have
written now
is not related to Lisp, but defending myself against an unfair attack.
Wouldn't
it be much simpler if someone answered: "No, there is no such Lisp
implementation, use Kawa(which is also a Lisp dialect)", or "Yes,
implementation XYZ offers what you need." Would have spared bandwith
and time.
Thank you Tim Haynes for taking your stand.
Feel free to flame me if you want, I wouldn't post here if I couldn't
stand it.
From: Tim Bradshaw
Subject: Re: Need free/portable Lisp with Database access
Date:
Message-ID: <ey3isu41att.fsf@cley.com>
* thelifter wrote:
> Now I also remember Paul Graham who used Clisp in his famous program
> that became Yahoo shopping, stating that he used the Unix filesystem
> to store the data. I realize that his choice was also motivated by
> necessity :)
No, it was motivated by the Unix filesystem actually being a really
good database for many purposes.
Tim Bradshaw wrote:
> * thelifter wrote:
>
>>Now I also remember Paul Graham who used Clisp in his famous program
>>that became Yahoo shopping, stating that he used the Unix filesystem
>>to store the data. I realize that his choice was also motivated by
>>necessity :)
>
>
> No, it was motivated by the Unix filesystem actually being a really
> good database for many purposes.
Could you please explain this in more detail?
Several times I was tempted to use a database for storing data but I
always ended up with storing the data in files. The main reason was that
it worked that way and that a database solution would have been much
more effort. But I didn't really think much about that point and would
be interested in arguments.Is there a difference between UNIX and
Windows file systems when using them as databases?
Regards
Rolf Wester
Rolf Wester <······@ilt.fhg.de> writes:
> Tim Bradshaw wrote:
> > * thelifter wrote:
> >
> >>Now I also remember Paul Graham who used Clisp in his famous program
> >>that became Yahoo shopping, stating that he used the Unix filesystem
> >>to store the data. I realize that his choice was also motivated by
> >>necessity :)
> > No, it was motivated by the Unix filesystem actually being a really
> > good database for many purposes.
>
> Could you please explain this in more detail?
>
> Several times I was tempted to use a database for storing data but I
> always ended up with storing the data in files. The main reason was
> that
> it worked that way and that a database solution would have been much
> more effort. But I didn't really think much about that point and would
> be interested in arguments.Is there a difference between UNIX and
> Windows file systems when using them as databases?
The one time I did a concious choice to use a (local) unix file system
as persistent storage is that the operations I did on my data items
(essentially shuffling work items through a workflow map) mapped quite
well to "move files between directories" and "symlinks" (each file is
a work item, each action point is a directory-with-structure (one
subdirectory for items and one for exits) and the symlinks link to the
possible next actions).
This can, obviously, be modelled in an RDBMS, but it is actually more
effort.
//Ingvar
--
(defmacro fakelambda (args &body body) `(labels ((me ,args ,@body)) #'me))
(funcall (fakelambda (a b) (if (zerop (length a)) b (format nil "~a~a"
(aref a 0) (me b (subseq a 1))))) "Js nte iphce" "utaohrls akr")
Ingvar Mattsson <······@cathouse.bofh.se> writes:
> The one time I did a concious choice to use a (local) unix file system as
> persistent storage is that the operations I did on my data items
> (essentially shuffling work items through a workflow map) mapped quite
> well to "move files between directories" and "symlinks" (each file is a
> work item, each action point is a directory-with-structure (one
> subdirectory for items and one for exits) and the symlinks link to the
> possible next actions).
>
> This can, obviously, be modelled in an RDBMS, but it is actually more
> effort.
This, while interesting and valid, is not the whole story. The People have
RDBMSen; The People want to *use* RDBMSen. (They're mad, but they pay the
salary.)
To give the impression `users of this language think RDBMSs suck and can be
implemented entirely in the filesystem', to the extent that no one
implementation manages multi-platform multi-DBMS capabilities, seems a
little like sadly neglecting a chance for expansion, to me.
Anyway, I've had some help in finding add-on bits for DrScheme; I've got
toys of a slightly-lisp-ish form to play with, now. :)
~Tim
--
I never knew that the ·······@stirfried.vegetable.org.uk
light of ages breaks the way before us |http://spodzone.org.uk/
Tim Haynes <···············@stirfried.vegetable.org.uk> writes:
> Ingvar Mattsson <······@cathouse.bofh.se> writes:
>
> > The one time I did a concious choice to use a (local) unix file system as
> > persistent storage is that the operations I did on my data items
> > (essentially shuffling work items through a workflow map) mapped quite
> > well to "move files between directories" and "symlinks" (each file is a
> > work item, each action point is a directory-with-structure (one
> > subdirectory for items and one for exits) and the symlinks link to the
> > possible next actions).
> >
> > This can, obviously, be modelled in an RDBMS, but it is actually more
> > effort.
>
> This, while interesting and valid, is not the whole story. The People have
> RDBMSen; The People want to *use* RDBMSen. (They're mad, but they pay the
> salary.)
> To give the impression `users of this language think RDBMSs suck and can be
> implemented entirely in the filesystem', to the extent that no one
> implementation manages multi-platform multi-DBMS capabilities, seems a
> little like sadly neglecting a chance for expansion, to me.
Heh. The language in question was actually C, where interfacing to an
RDBMS is even more of an effort.
I see it as another case of "right tool for the job, or at least as
close to the right tool as you can get with suitable effort".
//Ingvar
--
When the SysAdmin answers the phone politely, say "sorry", hang up and
run awaaaaay!
Informal advice to users at Karolinska Institutet, 1993-1994
From: Tim Bradshaw
Subject: Re: Need free/portable Lisp with Database access
Date:
Message-ID: <ey3n0jfk7z9.fsf@cley.com>
* Tim Haynes wrote:
> This, while interesting and valid, is not the whole story. The
> People have RDBMSen; The People want to *use* RDBMSen. (They're mad,
> but they pay the salary.) To give the impression `users of this
> language think RDBMSs suck and can be implemented entirely in the
> filesystem', to the extent that no one implementation manages
> multi-platform multi-DBMS capabilities, seems a little like sadly
> neglecting a chance for expansion, to me.
But this is also not true. LW has SQL support, which supports
ODBC[1], and runs, I guess on PCs, Macs (soon by the look of it) linux
and many Unix systems. There is a free semi-clone of this which runs
in implementations. Allegro probably has multi-platform DB support
and runs on everything from a palm pilot (Duane is bound to have
ported it...) to a Sunfire.
Get *over* this stupidity.
Footnotes:
[1] yes, I know, a commercial Lisp license is several hundred
dollars, and that's `too much'. Especially given that Oracle is,
erm, oh, well, tens of thousands of dollars, and somehow isn't
`too much'.
Tim Bradshaw <···@cley.com> writes:
> Get *over* this stupidity.
>
> Footnotes: [1] yes, I know, a commercial Lisp license is several hundred
> dollars, and that's `too much'. Especially given that Oracle is, erm, oh,
> well, tens of thousands of dollars, and somehow isn't `too much'.
I run one or two 100% Open-Source environment on both financial and
ideological grounds. So far that has got me a choice of adequate database
systems. Telling me that `odbc bindings exist but you've got to pay to use
a restricted license on them' isn't going to wash, especially when I can
get what I want (in order to *learn* - there's no guarantee that I'd *like*
Allegro or whatever) from Scheme. This thread really now belongs on c.l.s.
~Tim
--
Back on the stamping ground ·······@stirfried.vegetable.org.uk
Where it all began |http://spodzone.org.uk/
Tim Haynes wrote:
> Tim Bradshaw writes:
>
>
> >Get *over* this stupidity.
> >
> >Footnotes: [1] yes, I know, a commercial Lisp license is several hundred
> >dollars, and that's `too much'. Especially given that Oracle is, erm, oh,
> >well, tens of thousands of dollars, and somehow isn't `too much'.
>
>
> I run one or two 100% Open-Source environment on both financial and
> ideological grounds. So far that has got me a choice of adequate database
> systems. Telling me that `odbc bindings exist but you've got to pay to use
> a restricted license on them' isn't going to wash, especially when I can
> get what I want (in order to *learn* - there's no guarantee that I'd
> *like*
> Allegro or whatever) from Scheme. This thread really now belongs on c.l.s.
At a certain point in our lab we ran some pretty serious database hookup
(Terabites of microspcopy images to be carefully indexed) using CMUCL +
MaiSL (UncommonSQL) + Postgres. Worked without a hitch. That sould take
care of the "free" issue.
Now we have an issue with "no ``free'' alternative on Windows". Well,
in the spirit of "free software", if the software is not up to par on
windows you can chip in. Port MaiSQL/UncommonSQL to Ecl (or CLisp). For
200 buck you get to play around with Corman Lisp. The user community
and Roger Corman himself are a delightful bunch of people. And, by
sticking to Common Lisp, at least you can leverage a more useful
language than Scheme to start with.
So the question is: how much effort are you going to put in into making
free software better? (Provided that - at least in this forum -
"switching to Scheme" definitively does not account as a step in that
direction. :) )
Cheers
--
Marco Antoniotti
Tim Haynes <···············@stirfried.vegetable.org.uk> writes:
> This thread really now belongs on c.l.s.
yes, excellent, take it away, this post will help you with the FUT!
--
(espen)
From: Tim Bradshaw
Subject: Re: Need free/portable Lisp with Database access
Date:
Message-ID: <ey3u1dnincr.fsf@cley.com>
* Tim Haynes wrote:
> I run one or two 100% Open-Source environment on both financial and
> ideological grounds.
Good for you, I'm sure you've costed everything really carefully, and
follow all the fashionable ideologies.
> This thread really now belongs on c.l.s.
I agree. Have fun over there, then.
--tim
Followups set
From: Tim Bradshaw
Subject: Re: Need free/portable Lisp with Database access
Date:
Message-ID: <ey3r88rk8aq.fsf@cley.com>
* Rolf Wester wrote:
> Could you please explain this in more detail?
> Several times I was tempted to use a database for storing data but I
> always ended up with storing the data in files. The main reason was
> that it worked that way and that a database solution would have been
> much more effort. But I didn't really think much about that point
> and would be interested in arguments.Is there a difference between
> UNIX and Windows file systems when using them as databases?
I don't think there's really much to explain. There isn't a
difference between using the Unix Windows FS that I can see - maybe
Unix is higher performance on average or something. The main thing is
that a filesystem gives you a structured namespace and very
high-performance storage of arbitrary data in files. If that's what
you need - in particular if you don't need relational or transactional
stuff, then a filesystem is great.
--tim
From: Joe Marshall
Subject: Re: Need free/portable Lisp with Database access
Date:
Message-ID: <adfffsr4.fsf@ccs.neu.edu>
Tim Bradshaw <···@cley.com> writes:
> No, it was motivated by the Unix filesystem actually being a really
> good database for many purposes.
Huh?! No transactions, no isolation, no atomicity, consistency
problems... the Unix file system is a piss-poor database. If you are
lucky you get durability (but not with NFS).
From: Tim Bradshaw
Subject: Re: Need free/portable Lisp with Database access
Date:
Message-ID: <ey3wuijxxfp.fsf@cley.com>
* Joe Marshall wrote:
> Huh?! No transactions, no isolation, no atomicity, consistency
> problems... the Unix file system is a piss-poor database. If you are
> lucky you get durability (but not with NFS).
If you don't need these things, then it's fine, and not all databases
need them, witness the success of MySQL which (until recently, anyway)
didn't have transactions.
--tim
Joe Marshall <···@ccs.neu.edu> writes:
> Tim Bradshaw <···@cley.com> writes:
>
>> No, it was motivated by the Unix filesystem actually being a really
>> good database for many purposes.
>
> Huh?! No transactions, no isolation, no atomicity, consistency
> problems... the Unix file system is a piss-poor database. If you are
> lucky you get durability (but not with NFS).
Attacking the Unix filesystem on the basis of faults in NFS is like
attacking Common Lisp because dynamic-wind is difficult/impossible to
implement well on a multiple-CPU system. There are a bunch of unix
and unix-like file systems, Posix describes their semantics, and NFS
(despite often being found on Sun boxes) doesn't even come close.
That aside, some people say "database" and think "ACID", other people
think "collection of data, arranged in some way that we can find it
again". I guess this is not so different from the way that some people
say "OOP" and think "Encapsulation, Inheritance, Polymorphism" and
others think "object identity". YM, as always, MV
-dan
--
http://www.cliki.net/ - Link farm for free CL-on-Unix resources
In article <····························@posting.google.com>,
·········@gmx.net (thelifter) wrote:
> Now I also remember Paul Graham
> who used Clisp in his famous program that became Yahoo shopping,
> stating
> that he used the Unix filesystem to store the data. I realize that his
> choice
> was also motivated by necessity :)
No, he explicitly states in his articles that using databases is a bad
idea. He claims you get some real benefits from using text files
containing s-expressions. IMHO he has some good points.
> Since I lurk in this group for some while and have read a LOT of
> archived articles from it, I was somewhat used to the rough tone of
> some of the inhabitants.
Obviously not recently because...
> There is another person here who also likes to share negative comments
> about others
> and his name is Erik Naggum.
... Erik hasn't posted here for nearly three months by now.
Pascal
--
"If I could explain it, I wouldn't be able to do it."
A.M.McKenzie