Hi ,
I would just like to address the Thread that has been running for
the last few months on CL-HTTP , FRANZ and ALLEGRO-SERVE. I was
_burdened_ :) with the task of documenting the features of CL-HTTP
for an internship project over the summer. I got stuck into it
immediately and after a few problems which I resolved it came to the
point of asking a few questions. Right I said this should be straight
forward , find a mailing list , post to the mailing list , receive an
answer , problem solved.
But no they screamed in Unison!!!
I found the www-cl list quite quickly , I posted , all was silent and
then WHACK!!! , John C Mallery parps in with "Read the Documentation".
All well an good if there was documentation. A few More
posts and I got "Read the Code", again thats all well and good if the
code was commented and not spread in a heap over vast ranges of my hard
disk.
It is actually quite strange, there are loads of people on that list,
However when a query comes in they respond with a personal email rather
than posting to the list (except for Mallery). They all seem either
intimidated by the guy or a friend who does not want to back stab him
by giving ACL help on the list.
Personally I don't blame the guy for getting a bit annoyed. I mean it is
your classic case of man has idea , man implements idea , man
distributes code, other man ports code , other man steals idea , other
man implements code, other man stops supporting original code, other man
distributes code. John Mallery has basically been messed about and he is
a bit cheesed off, However it would not have happened if :
a) CL-HTTP had been documented (current version 70-23 has
documentation from 1996!!!)
b) John Mallery was at least polite if not helpful on the www-cl list
In order for people to stay with your product if your idea is stolen
you need to have people who want to us your product because it's easy
to use and you can get help from the distributor when needed.
Anyway i have moved to Allegro Serve now , It is less codie , has good
documentation and people answer questions if they can when asked. I am
not franz's best buddy in the world , I think their prices are a bit
high but the university i am going to is paying so what the hey.
I am going to put up a webpage with a HOW-TO on both CL-HTTP and
AllegroServe in the future as I want lisp to flourish unlike many lisp
users and developers who appear to prefer to fight internally with each
other, rather than help each other out and make lisp a better and more
commonly used language. Oh yeah and fair play to Sunil for LSP it looks
good and I will be using it with AllegroServe next year.
Michael Kerrigan
University College Dublin
Sent via Deja.com http://www.deja.com/
Before you buy.
In article <············@nnrp1.deja.com>, ····@netsoc.ucd.ie wrote:
> I found the www-cl list quite quickly , I posted , all was silent and
> then WHACK!!! , John C Mallery parps in with "Read the Documentation".
> All well an good if there was documentation.
a) Franz is a company selling Lisp based software and
selling support for Lisp software.
b) CL-HTTP is the additional result of an AI research
group at MIT. It has been a research tool.
It also has been deployed a couple
of times. Many people have contributed, ported
or debugged it. It has been enhanced in several
projects.
> a) CL-HTTP had been documented (current version 70-23 has
> documentation from 1996!!!)
It is around since then and basic design hasn't changed
much. You still use EXPORT-URL to export URLs.
You are expected to understand the source code for using
CL-HTTP. If not you are lost easily. You also need to
understand most of Common Lisp and extensions of
it. You also may want to use an advanced Lisp
environment.
Btw., CL-HTTP has a **lot** of documentation and many examples.
Maybe too much for most people to be able to read them or find
them. Hint: examples are in examples and contributions
directories. Read them. They will answer most questions.
First time you start CL-HTTP it should come up with
web access to documentation and examples.
> I am going to put up a webpage with a HOW-TO on both CL-HTTP and
> AllegroServe
A contribution is welcome.
> in the future as I want lisp to flourish unlike many lisp
> users and developers who appear to prefer to fight internally with each
> other,
I don't think perception is accurate. Just look which
useful Lisp applications have been made accessible in the
last years and who wrote it. I haven't seen much applications
that have left early sketch state or prototype state
and that are available on the net (besides some AI systems)
as source.
> rather than help each other out and make lisp a better and more
> commonly used language.
But Lisp developers are not better for some reason than the rest
of the world. Actually some of the Lisp code is worth a lot of
money. Maybe from the university the world looks innocent...
;-)
Rainer Joswig
--
Rainer Joswig, BU Partner,
ISION Internet AG, Steinh�ft 9, 20459 Hamburg, Germany
Tel: +49 40 3070 2950, Fax: +49 40 3070 2999
Email: ····················@ision.net WWW: http://www.ision.net/
In article <···································@news.is-europe.net>,
Rainer Joswig <·············@ision.net> wrote:
> In article <············@nnrp1.deja.com>, ····@netsoc.ucd.ie wrote:
>
> > I found the www-cl list quite quickly , I posted , all was silent
and
> > then WHACK!!! , John C Mallery parps in with "Read the
Documentation".
> > All well an good if there was documentation.
>
> a) Franz is a company selling Lisp based software and
> selling support for Lisp software.
>
> b) CL-HTTP is the additional result of an AI research
> group at MIT. It has been a research tool.
> It also has been deployed a couple
> of times. Many people have contributed, ported
> or debugged it. It has been enhanced in several
> projects.
This makes no difference, if a research project is undertaken it is
absolutely worthless unless someone else can reproduce your findings
with ease. The point of research is to spend mountains of time figuring
things out and then to explain simply to other people how to use it so
they can be productive in their area without having to spend the
mountains of time solving basic niggly problems. John Mallery has done
the opposite.
>
> > a) CL-HTTP had been documented (current version 70-23 has
> > documentation from 1996!!!)
>
> It is around since then and basic design hasn't changed
> much. You still use EXPORT-URL to export URLs.
yes but things have changed and documentation should have been
added/changed.
>
> You are expected to understand the source code for using
> CL-HTTP. If not you are lost easily. You also need to
> understand most of Common Lisp and extensions of
> it. You also may want to use an advanced Lisp
> environment.
See my point above, it is relatively easy for someone who has written
some software to add commenting here and there and to give a page of
information on how to use it. It is less easy for someone who knows lisp
but has never used CL-HTTP before, to come along and *interpret* 70 odd
files.
>
> Btw., CL-HTTP has a **lot** of documentation and many examples.
> Maybe too much for most people to be able to read them or find
> them.
(roflmao) examples in Cl-HTTP consist of reams of unreadable code that
call on macro's which call on macro's which call on macro's, following
another coders code is only possible if he has *commented* it
(especially in lisp). Have you every tried to work out a 3 line perl
script which does everything from making you a cup of tea to creating
world peace, yes, well cl-http is even harder than that.
> Hint: examples are in examples and contributions
> directories. Read them.
This is the sort of attitude that John Mallery holds it does'nt help
anyone (in fact it is downright condescending), all it does is leave you
lost and without any help. All people actually want is an answer. We are
all civilised adults and yet very few people are willing to help there
fellow man and spend 15 minutes writting a helpful response.
> They will answer most questions.
> First time you start CL-HTTP it should come up with
> web access to documentation and examples.
>
> > I am going to put up a webpage with a HOW-TO on both CL-HTTP and
> > AllegroServe
>
> A contribution is welcome.
>
> > in the future as I want lisp to flourish unlike many lisp
> > users and developers who appear to prefer to fight internally with
each
> > other,
>
> I don't think perception is accurate. Just look which
> useful Lisp applications have been made accessible in the
> last years and who wrote it. I haven't seen much applications
> that have left early sketch state or prototype state
> and that are available on the net (besides some AI systems)
> as source.
Thats a fair comment, as i stated in my last email, the lisp community
should pull together and those of us that can code in lisp should port
GPL'd code, and make available our "little handy programs", what is
needed is a handy center where contributions can be made and programs
can be grabbed for free.
>
> > rather than help each other out and make lisp a better and more
> > commonly used language.
>
> But Lisp developers are not better for some reason than the rest
> of the world. Actually some of the Lisp code is worth a lot of
> money. Maybe from the university the world looks innocent...
> ;-)
I am not saying that lisp developers are better, just that lisp should
be bigger and better than it is and that internal rows are and have been
pulling lisp down. We need to help one another out and not say things
like "Well I know and you don't so go away and learn it then you will be
worth to know it".
~Mick
>
> Rainer Joswig
>
> --
> Rainer Joswig, BU Partner,
> ISION Internet AG, Steinh�ft 9, 20459 Hamburg, Germany
> Tel: +49 40 3070 2950, Fax: +49 40 3070 2999
> Email: ····················@ision.net WWW: http://www.ision.net/
>
Sent via Deja.com http://www.deja.com/
Before you buy.
····@netsoc.ucd.ie writes:
> Thats a fair comment, as i stated in my last email, the lisp community
> should pull together and those of us that can code in lisp should port
> GPL'd code, and make available our "little handy programs", what is
> needed is a handy center where contributions can be made and programs
> can be grabbed for free.
http://clocc.sourceforge.net/
--
vsync
http://quadium.net/ - last updated Fri Jun 30 22:55:16 MDT 2000
(cons (cons (car (cons 'c 'r)) (cdr (cons 'a 'o))) ; Orjner
(cons (cons (car (cons 'n 'c)) (cdr (cons nil 's))) nil)))
····@netsoc.ucd.ie writes:
> This makes no difference, if a research project is undertaken it is
> absolutely worthless unless someone else can reproduce your findings
> with ease. The point of research is to spend mountains of time
> figuring things out and then to explain simply to other people how
> to use it so they can be productive in their area without having to
> spend the mountains of time solving basic niggly problems. John
> Mallery has done the opposite.
The level of user/developer which a research tool is going to be
suited for is different from a tool which is meant to be widely used
by non-researching developers and/or end-users. Just as one must take
into consideration the audience a literary work was intended for, we
must also undersand what users were intended to make use of a program.
The explanations of what cl-http based research has revealed is to be
found in the various papers the home page links too, and often any
code that was generated in he course of this research included in the
cl-http distribution. Those who are doing research often do not have
the free labor available to make their tools accesable by the majority
of users. This is a fairly common situation for university software.
The only way it gets solved is for someone with the labor available to
produce documentation for ther research tool and do the polishing and
generalization neccesarry to make a research tool into a general
development tool. Castigating others accomplishes nothing.
> This is the sort of attitude that John Mallery holds it does'nt help
> anyone (in fact it is downright condescending), all it does is leave you
> lost and without any help. All people actually want is an answer. We are
> all civilised adults and yet very few people are willing to help there
> fellow man and spend 15 minutes writting a helpful response.
He and others are offering you the best that they have to offer. They
can't refer you to non-existent documentation, and they don't have the
free labor available to write the documentation you need. That you
are taking there responses as insulting or derogatory is a personal
issue. The reciprocal is also true, and because of this it's usually
more fruitful to take a cooperative stance, as opposed to an
accusatory stance when pointing out shortcomings in a project which is
limiting it's accesability.
> Thats a fair comment, as i stated in my last email, the lisp community
> should pull together and those of us that can code in lisp should port
> GPL'd code, and make available our "little handy programs", what is
> needed is a handy center where contributions can be made and programs
> can be grabbed for free.
See Sam Steingold's "Common Lisp Open Code Collection" at
http://clocc.sourceforge.net
> I am not saying that lisp developers are better, just that lisp should
> be bigger and better than it is and that internal rows are and have been
> pulling lisp down. We need to help one another out and not say things
> like "Well I know and you don't so go away and learn it then you will be
> worth to know it".
Then write code and/or documentation.
--
Craig Brozefsky <·····@red-bean.com>
Lisp Web Dev List http://www.red-bean.com/lispweb
--- The only good lisper is a coding lisper. ---
In article <············@nnrp1.deja.com>, ····@netsoc.ucd.ie wrote:
> This makes no difference, if a research project is undertaken it is
> absolutely worthless unless someone else can reproduce your findings
> with ease.
I can't really follow it...
> (roflmao) examples in Cl-HTTP consist of reams of unreadable code
There are a lot of examples with a varying degree of complication
(chat server, VRML, Mail archive, browser capabilities,
image maps, exporting files, ...). The usual starting
point is "http:examples;exports.lisp".
As I said, maybe you should learn some advanced Lisp programming
first and come back later. A competent Lisp environment might
also help. Usually I don't have a problem to write/debug
CL-HTTP code. I'm just using the usual tools (m-. ,
show documentation, who calls, trace, advice, etc.).
Since I'm a MCL user, I have for example contributed
a large menu from where you can edit/load/compile
the various subsystems, start CL-HTTP, change preferences,
open URLs, inspect various crucial Lisp datastructures, ...
Currently I'm reimplementing these tools portably in CLIM.
Sadly code doesn't write itself - somebody has to do it.
> Thats a fair comment, as i stated in my last email, the lisp community
> should pull together and those of us that can code in lisp should port
> GPL'd code, and make available our "little handy programs", what is
> needed is a handy center where contributions can be made and programs
> can be grabbed for free.
What I'm interested in is: cool Lisp applications and
extensible libraries. Little handy programs I could
write in whatever.
> I am not saying that lisp developers are better, just that lisp should
> be bigger and better than it is and that internal rows are and have been
> pulling lisp down. We need to help one another out and not say things
> like "Well I know and you don't so go away and learn it then you will be
> worth to know it".
As I said: Look who has what contributed in the last years
and who has advanced the state of Lisp in the last years.
I've heard a lot people complaining in the last years, but
when it comes down to write/publish/maintain
actual ***working*** code things suddenly change. Given
that Lisp is the world's greatest programming language we should
see a lot of cool **programs**. But instead mostly I hear
people complaining and not publishing software.
Maybe Lisp is too complex or they don't have enough time
or whatever. If they can't read code using macros, they
better look for something else.
CL-HTTP really stands out in as much that it has been
available and maintained on several platforms
over several years.
Everybody is invited either to contribute or to do it
themselves - preferrably better.
--
Rainer Joswig, BU Partner,
ISION Internet AG, Steinh�ft 9, 20459 Hamburg, Germany
Tel: +49 40 3070 2950, Fax: +49 40 3070 2999
Email: ····················@ision.net WWW: http://www.ision.net/
In article <············@nnrp1.deja.com>, ····@netsoc.ucd.ie wrote:
> with ease. The point of research is to spend mountains of time figuring
> things out
and
> (roflmao) examples in Cl-HTTP consist of reams of unreadable code that
> call on macro's which call on macro's which call on macro's, following
> another coders code is only possible if he has *commented* it
> (especially in lisp). Have you every tried to work out a 3 line perl
> script which does everything from making you a cup of tea to creating
> world peace, yes, well cl-http is even harder than that.
Let's look at the web server docs and the Lisp examples.
I have currently CL-HTTP running on my Powerbook while
writing this message - so don't be irritated by the
IP number of my Mac. Just use your copy of CL-HTTP
with your DNS name or IP-number...
First we start with the documentation. In MCL it is especially
hard to get there: you just select it from the CL-HTTP menu
under "Open URL in Browser:Local, this server".
Start frame of CL-HTTP:
http://194.163.195.67/cl-http/frame.html
Basic idea of the web server project:
http://194.163.195.67/projects/iiip/doc/cl-http/server-abstract.html
Find Documentation dialog for Lisp documentation:
http://194.163.195.67/cl-http/find-documentation.html
For example, documentation of EXPORT-URL:
http://194.163.195.67/cl-http/show-documentation?HTTP:EXPORT-URL
Documentation for the facilities for writing
response functions:
http://194.163.195.67/cl-http/response-functions.html
Documentation showing how to export non-HTML data, in this
case examples using VRML1 generation.
http://194.163.195.67/cl-http/vrml/vrml.html
Description about various platform issues:
http://194.163.195.67/cl-http/platforms.html
Documentation about the Presentation substrate:
http://194.163.195.67/cl-http/w3p/w3p.html
Showcase and description of various server features:
http://194.163.195.67/cl-http/features.html
Coding guidelines:
http://194.163.195.67/cl-http/guidelines.html
Basic server extension:
http://194.163.195.67/cl-http/extensions.html
Mailing List Archive (yes, again eating its own dog food)
http://wilson.ai.mit.edu/cl-http/archives/www-cl.html
etc., etc., etc., ...
I mean, it has tons of documentation.
Now let's look at some of the example code:
-> http:examples;exports.lisp (first hurdle, yes we use logical pathnames)
;; Note that #U is a reader macro that completes a partial URL according
;; to the local context in which is it evaluated, see HTTP:MERGE-URL
;; Export CL-HTTP Documentation
(export-url #u"/cl-http/"
:directory
:recursive-p t
:pathname "http:www;cl-http;"
:expiration `(:interval ,(* 15. 60.))
:public t
:language :en
:keywords '(:cl-http :documentation))
Wow, this looks complicated. A Lisp function exporting an URL.
And the syntax of the #U reader macro explained in a comment.
If you want to know more about EXPORT-URL, just move your cursor
to it and press "c-x c-d" (this may vary for your Lisp implementation,
mine is MCL) - up pops 22038 characters of documentation in a window.
All you need to be able is to use your Lisp system and read the fucking
documentation.
Now let's investigate the top level frame.
(defparameter *sections* '(("Overview"
...
Well, this looks like a definition for the sections in the menu
of the top level frame. Surprise.
(defmethod write-cl-http-index-pane ((url http-url) stream)
...
Maybe a function to write the CL-HTTP index pane? Could be.
Reading the code makes this very likely, since the function
is writing the sections nicely formatted to the response
stream as an HTML page. Doing "c-x c-d" on the symbols reveals
that just ****every**** used CL-HTTP construct has a documentation
string which describes the purpose and usage of it. M-. on the symbol
will find the source of ***every*** construct in less than a second.
(export-url #u"/cl-http/frame-index.html"
:computed
:response-function #'write-cl-http-index-pane
:expiration `(:interval ,(* 15. 60.))
:public t
:language :en
:keywords `(:cl-http :documentation))
Wow, we are exporting the above function and it will be called
when the client gets this URL with the URL object and the
TCP stream as parameters. How complicated.
Etc., etc.
Sorry, but some of you will have a hard time when you are not
able to find and read documentation and the Lisp source.
This way we won't be able to advance the state of Lisp
applications...
--
Rainer Joswig, BU Partner,
ISION Internet AG, Steinh�ft 9, 20459 Hamburg, Germany
Tel: +49 40 3070 2950, Fax: +49 40 3070 2999
Email: ····················@ision.net WWW: http://www.ision.net/
* mick wrote:
> (roflmao) examples in Cl-HTTP consist of reams of unreadable code that
> call on macro's which call on macro's which call on macro's, following
> another coders code is only possible if he has *commented* it
> (especially in lisp). Have you every tried to work out a 3 line perl
> script which does everything from making you a cup of tea to creating
> world peace, yes, well cl-http is even harder than that.
I think that's kind of unfair to cl-http. I haven't looked at it for
a couple of years, but it always looked to me like a fairly standard
`MIT-style' system: not surprisingly since it came from MIT. It's
pretty reminiscent of things like the Symbolics sources and CLIM.
The problem with all these things is that they're extremely -- some
would say gratuitously -- complex designs, end extremely complex and
typically highly macrified implementations of the designs. They also
assume you have something like a lispm with all the tightly-integrated
code exploration tools they have in order to hack them. And they
often have other irritating characteristics like assuming a
longer-than-80-character line width (zmacs windows are typically wider
than 80 cols) and so on.
If you have ACL, then Franz's eli interface can get you quite a lot of
the way with these things -- so long as you compile with flags so that
M-. works pervasively, and remember that you can recursively
macroexpand things from within the expansion buffer. Things like
class / call graphing tools are a win too, and if you have CLIM you
can trivially write the former, and slightly less trivially (you need
access to the internal who-calls database) write the latter.
I'm sure the other commercial Lisps have similarly good tools, I'm
just not familar with them.
The fundamental problem with MIT-style programs, though, is that MIT
people have bigger brains than most of the rest of us, so it is just
unavoidably hard to understand the stuff they write.
--tim
On Tue, 04 Jul 2000 00:30:19 GMT, ····@netsoc.ucd.ie wrote:
> I am going to put up a webpage with a HOW-TO on both CL-HTTP and
> AllegroServe in the future as I want lisp to flourish unlike many lisp
When you have the AllegroServe page ready, please consider adding a link to
it from CLiki:
http://ww.telent.net/cliki/
Everybody has write access to the site.
Paolo
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/
In article <············@nnrp1.deja.com>, ····@netsoc.ucd.ie says...
>
> Personally I don't blame the guy for getting a bit annoyed. I mean it is
> your classic case of man has idea , man implements idea , man
> distributes code, other man ports code , other man steals idea , other
> man implements code, other man stops supporting original code, other man
> distributes code. John Mallery has basically been messed about and he is
> a bit cheesed off,
I assume that I'm the 'other man' referred to here and I have to set
the record straight. First, other people did the port of cl-http
to acl. I refined their work in the latest port, the one to Acl 5.0.1.
Second, cl-http wasn't the first web server, though it was the first
web server in Lisp to get any notoriety. But by that measure if MacLisp
was the first lisp to have a serious compiler, does that mean that the
compiler in Acl is ripoff of the MacLisp compiler idea? I'd say rather
that it's the natural evolution of Lisp that compilers would become a
standard feature. Likewise Lisp has evolved over the years to include
socket libraries and now with the web so pervasive I'd say that a web
server capability in Lisp (or any language) is no longer a novelty but a
necessity.
So if AllegroServe is a ripoff of anything it's a ripoff of the Apache
web server whose existence is in a large part responsible for where we
are today with the web.
As far as the implication that cl-http code and ideas were stolen in
AllegroServe, the code for both is out there in public view. Please
feel free to use your favorite file comparison program to search for any
lines of code in common. I don't think you'll find any.
But more important than that is that the emphasis in AllegroServe is
different (I'm not claiming that it's *better* but I am claiming that
it's different). AllegroServe is all about getting you up and running
quickly with no configuration issues. The html generation in
AllegroServe is based on pure html which is documented in thousands of
books (and great hyperlinked html spec (which is what I personally
use)). The documentation in AllegroServe is the traditional manual
and tutorial rather than distributed throughout the code.
AllegroServe is not just a ripoff of cl-http, in implementation or
ideas. Whether it's better or worse is not for me to judge. I think
that it's good that there is a choice and I look forward to seeing other
web servers written in Lisp that solve the problem in new and
interesting ways.
-john foderaro
John Foderaro <···@franz.com> writes:
> In article <············@nnrp1.deja.com>, ····@netsoc.ucd.ie says...
> >
> > Personally I don't blame the guy for getting a bit annoyed. I mean it is
> > your classic case of man has idea , man implements idea , man
> > distributes code, other man ports code , other man steals idea , other
> > man implements code, other man stops supporting original code, other man
> > distributes code. John Mallery has basically been messed about and he is
> > a bit cheesed off,
>
> So if AllegroServe is a ripoff of anything it's a ripoff of the Apache
> web server whose existence is in a large part responsible for where we
> are today with the web.
yes. I agree. If anyone, including the author of CL-HTTP is pissed off
that another web server uses similar ideas, then he should get a grip on
life, on software development, and on his ego, which is probably out of
control if he is indeed "cheesed off". Of course, I don't know him, so
please note the "if".
Now, as of now, AllegroServe only works on ACL, last I checked. I liked
it a lot, almost as much as I dislike CL-HTTP. I went through the
AllegroServe sources like reading a novel; CL-HTTP was like reading
Russian. AllegroServe makes sense. It's not all over the place. I
understand Rainer's post about mostly sufficient documentation on
CL-HTTP too. I think that there's enough on CL-HTTP that you could have
a really great site using it. CL-HTTP certainly has more features than
AllegroServe. But it seems that the features/complexity trade-off was
ignored.
Readers should note that while AllegroServe was written using
ACL-specific stuff for sockets, threads, and even regexp, CL-HTTP is
pretty much platform-independent as a distribution for many CL
implementations. But the good news is that it wouldn't be hard at all
to port AllegroServe to your favorite CL implementation. I was
surprised that Franz decided to make it LGPL-like open-source.
The bottom line is that AllegroServe is simpler, has a better license,
and when it gets ported to HLW and such, it will probably be the
beginning of the end for CL-HTTP. I don't think that AllegroServe as it
was last I saw (i.e. only running on ACL) will be very useful to
businesses with finite money, considering that it's about $30K to get up
and running your ACL AllegroServe web server on a single-CPU box. I'd
rather do it on LispWorks for $2K, and toil through the port.
One thing that would have been nice in in AllegroServe is that it could
have been written with simpler portability in mind, so that someone
could come along and port it a bit more easily. But I think it's pretty
straightforward for LispWorks, though I havn't tried it just yet. If
it's been done already, well, then there you go.
dave