I don't know how widely known this is, so I appologize if you've seen
it.
There's a programming contest sponsored by my employer, with a $1000
first prize.
You have to use Curl, not Lisp, but that should give this group a head
start over others for the short deadline (May 15).
General: http://www.curl.com
Contest: http://www.curl.com/html/developers/contestwelcome.jsp
For specific questions:
http://www.curl.com/html/developers/developers.jsp, or contact me
(·············@curl.com) if you don't find what you need.
>>>>> "hs" == Howard Stearns <·······@curl.com> writes:
hs> There's a programming contest sponsored by my employer, with a
hs> $1000 first prize.
hs> You have to use Curl, not Lisp, but that should give this group a
hs> head start over others for the short deadline (May 15).
I hardly see any ways that Curl is similar enough to Common Lisp that
someone would want to advertize this contest on a Lisp newsgroup.
Curl seems itself to be a language designed around the here-and-now
buzzwords and current technological innovations of the Web.
It's really weird. I would be much happier seeing people writing
Common Lisp extensions and libraries than write these new languages
which have little added value. Every time this is done, a whole new
syntax is created, new parsers, etc. etc. It's a lot of work that can
be avoided. I'd be surprised to see any serious Lisp developers
interested in Curl. I gave it a good half hour, and don't see the
value in it.
Writing a new language is a big deal. You have to consider all the
things that matter to programmers, such as database integration,
foreign calls, networking, I/O, etc. Why re-invent the wheel, and if
you *are* going to re-invent it, why make it inferior to what already
exists?
Anyway, just my $0.02. It's nice that someone can win a thousand
bucks by trying out a new language, and maybe even having fun with
it. I wouldn't mention this if this were a C++ newsgroup, since those
guys need to be motivated as much as possible to consider
alternatives. But not here. I don't see the advantages to yet
another programming language just because people are screaming about
XML. This seems like yet another language that will never get much of
a following. Still worth checking out? Yeah, I guess if you have
time. But I personally wasn't impressed.
dave
"David Bakhash" <·····@alum.mit.edu> wrote in message
···················@alum.mit.edu...
>
> It's really weird. I would be much happier seeing people writing
> Common Lisp extensions and libraries than write these new languages
> which have little added value. Every time this is done, a whole new
> syntax is created, new parsers, etc. etc. It's a lot of work that can
> be avoided. I'd be surprised to see any serious Lisp developers
> interested in Curl. I gave it a good half hour, and don't see the
> value in it.
>
> Writing a new language is a big deal. You have to consider all the
> things that matter to programmers, such as database integration,
> foreign calls, networking, I/O, etc. Why re-invent the wheel, and if
> you *are* going to re-invent it, why make it inferior to what already
> exists?
>
> Anyway, just my $0.02. It's nice that someone can win a thousand
> bucks by trying out a new language, and maybe even having fun with
> it. I wouldn't mention this if this were a C++ newsgroup, since those
> guys need to be motivated as much as possible to consider
> alternatives. But not here. I don't see the advantages to yet
> another programming language just because people are screaming about
> XML. This seems like yet another language that will never get much of
> a following. Still worth checking out? Yeah, I guess if you have
> time. But I personally wasn't impressed.
>
Well, given my short acquaintances with VBs, Java, and Curl, I'd prefer
Curl. I doubt it will go anywhere, VBs and J are `free' to anyone that
wants to write in them, I'm still waiting to see the fallout from the Curl
development. Of course comparing languages is always a troll. I'll stick
with the C/C++ stuff at work, try to improve my understanding of Lisp,
Prolog, and Forth in spite of my fellows arguments that they are
antiquated languages relegated to the dustbin and that I should really
should pay more attention to Java, etc. Phhht. 'Course there's still
Ada, Smalltalk, ML... (how the hell could anyone consider prolog to be
an old dog anyway? Antecedents?)
Geoff
>>>>> "gs" == Geoffrey Summerhayes <·············@hNoOtSmPAaMil.com> writes:
gs> Well, given my short acquaintances with VBs, Java, and Curl, I'd
gs> prefer Curl.
It's not about preferences. Writing serious software is a serious
issue, and you rely on a community to help with problems, on vendors
and developers, on libraries and other people's developments, etc. My
opinion on Java, while I don't really like it, is that it was
necessary because of the explosion of OSs, hardware platforms, etc.
It's not perfect, but it has helped salvage many projects without
asking developers to completely alter their programming mindset. It
was a pretty fair compromise, in my opinion.
Even if a language came alone that was significantly better (for me)
than Common Lisp, along with libraries, companies, etc, I might
recognize the improvement, but that doesn't mean that I'd start using
it. It would really have to let me do stuff that I couldn't otherwise
do in Perl and Common Lisp, which are the only two languages that I
tend to use.
Curl actually does attempt to do this by having special XML, graphics,
and Web support. I don't see it happening for the Curlers, though.
What Lisp has taught me is that no matter how well thought-out a
language is, it won't get the audience and usage it deserves. Common
Lisp is definitely the best designed language by a long way, and yet
its community is relatively small, and its usage in the commercial
world is negligible compared to Java and C++, despite its age.
That's why I always say: why don't these people use their resources to
augment Common Lisp? Curl features are, to me, superfluous to what a
language should be designed around. Its features are the very things
that could have been implemented elegantly in Common Lisp, all without
defining a whole new language.
dave
From: Howard Stearns
Subject: Lisp and Curl [Re: programming contest]
Date:
Message-ID: <3AF8147D.3F07CAEC@curl.com>
I have a slightly different way of looking at it.
I think arguments about the merits of Curl technology itself are best
discussed elsewhere. (I suggest
http://www.curl.com/cgi-bin/wwwthreads/wwwthreads.pl for
Curl-community stuff and
http://slashdot.org/articles/01/04/06/1335241.shtml for more, shall we
say, freewheeling discussion. I'd like to say to CC me if you want me
to reply, but it looks like neither of these sites allow you to do
that. sigh.)
However, I would like to share my reasoning about why I posted here
and said:
I don't know how widely known this is, so I appologize if you've
seen it.
There's a programming contest sponsored by my employer, with a
$1000 first prize.
You have to use Curl, not Lisp, but that should give this group
a head start over others for the short deadline (May 15).
It has to do with community, and with the
language/libraries/implementation troika.
COMMUNITY: I've all but given up on trying to define what could be
meant by the phrases "Lisp community" or "Lisp family of languages".
I don't know if Scheme and Dylan are Lisps, but I do feel comfortable
saying that Schemers, Dylanites, and even many Javanese are part of
some community with it's roots in Lisp. Surely it must be
uncontroversial that this can be said about at least the implementers
and other guiding lights of such languages.
See also, Kent Pitman's essay at
http://world.std.com/~pitman/PS/Lambda.html
I further feel that comp.lang.lisp is one of the best places for such
people to hang out together. I feel the newsgroup is about the
greater Lisp community as well as about Common Lisp.
The nascent Curl community is somewhat biased towards Lisp. Many of
the developers and the people using the technology outside of Curl
Corporation are part of the Lisp community. On the other hand,
there's strong market pressure not to draw such a comparison, and we
also have many people here who have little knowledge or love of things
Lisp. It will be for individual Lispers to choose whether to draw us
close or push us away.
In the mean time, I feel comfortable sharing news with my friends
here, and confident that the darn smart individuals are likely to be
able to put together a winning entry on short notice.
LANGUAGE: We've often discussed here how, when discussing programming
technology, "it's not about the language." It's about the combination
of LANGUAGE, LIBRARIES and IMPLEMENTATION.
Of course the Curl content language itself isn't "better" than Common
Lisp! Personally, I think of it as a "Worse is Better" Lisp, and only
barely a Lisp at that. (See
http://www.ai.mit.edu/docs/articles/good-news/subsection3.2.1.html)
Frankly, I doubt most people (in or out of Curl Corporation) would
think it is a Lisp family language at all. As a language, I think
it's a real problem that developers outside of Curl Corp. cannot write
general purpose macros or generic functions. But it does have
top-level procedures and an 'evaluate' function; full closures; gc;
conceptually run-time typing of everything (including primitives) and
a default variable declaration of 'any'; packages; multiple values;
positional, keyword and rest args; etc. There's enough in common
there that a Lisper should be able to pick it up pretty easily and do
well in a contest.
But, "the point" of Curl technology is not really the language. It's
how the language, the libraries, and the delivery mechanism of the
implementation come together to allow Web-centric applications. David
is right in that Curl technology IS about the "here-and-now buzzwords
and current technological innovations of the Web". We think that
stuff is important: full-service applications delivered through http;
richly interactive clients; better use of bandwidth; real peer-to-peer
environments;... -=> a real OS-independent, Web-centric platform for
connected applications.
That hasn't been delivered by either Lisp or by Java. If something in
between brings the world closer to the Lisp community, I've got no
problem with that.
David fairly asks why we didn't put our resources into doing this in
Lisp. You could say that that's exactly what happened (although I
wasn't there at the begining, so I can't say for sure). To borrow
(and change) a thought experiment from Kent's Lisp community article:
Imagine you wanted to use Lisp to deliver applications over the web.
Rightly or wrongly, you decide you need:
I. Very fast JIT compilation on the client for maximum application
performance while keeping applet start up time as low as possible.
II. A security model that prohibits certain kinds of compromising
activity from applets (unless they've been granted extra
permissions, which is to be considered very rare).
III. An underlying compile-time typing model to support both I and II.
IV. The ability to incorporate an HTML/XML like markup style directly
into an application. Indeed, you expect that, just as people
learned HTML by seeing source, you want people to be able to do
simple HTML-like things in your language and make the source
visible to others. (But you find prefix notation much more
succinct than that <begin>...</end> nonsense.) You then want
people to be able to add bits and pieces of programming without
throwing away what they've built and learned: a new markup
definition here; a procedure to return some repeated content there;
pretty soon you're doing real programming.
For example, there's a gentle learning slope between:
1. Raw text gets formatted for the page.
2. Stuff in curly braces get's evaluated based on the head of the
expression, and possibly some name1=value1, name2=value2 pairs
at the begining. Everything else in the tail is recursive
content in 1 or 2.
3. Some of the allowable heads of expression are more interesting,
such as define-text-format, let, set, if, define-proc, etc.
V. An influx of developers that bring some C++ and Java experience and
biases to the mix
There's probably more, but that's all I can think of at the moment.
(It's a wimpy disclaimer, I know, but I hope it will prevent anybody
from thinking of the above list as definitive.)
Well, given all that, these guys evolved their "Lisp" implementation
into what is now the Curl content language and Surge plug-in. No,
it's certainly not Common Lisp, or Scheme, etc. It is what it is.
Howard Stearns.
I work at Curl Corporation, but I speak for myself.
From: Tim Moore
Subject: Re: Lisp and Curl [Re: programming contest]
Date:
Message-ID: <9d9940$d08$0@216.39.145.192>
On Tue, 8 May 2001, Howard Stearns wrote:
> The nascent Curl community is somewhat biased towards Lisp. Many of
> the developers and the people using the technology outside of Curl
> Corporation are part of the Lisp community. On the other hand,
> there's strong market pressure not to draw such a comparison, and we
> also have many people here who have little knowledge or love of things
> Lisp. It will be for individual Lispers to choose whether to draw us
> close or push us away.
Are you serious? The AI winter was a decade ago! And you still feel
marketing pressure not to admit your language is Lisp-like?
Beware the fate of languages that bend over backwards to deny their Lisp
heritage (Dylan).
I saw a presentation by the Curl folks at my work. When we looked at
some source the presenter agreed with a nudge and a wink that it was
pretty Lispy. It looked like good stuff, but it's hard to imagine a
proprietary language, not sponsored by a monopoly, gaining traction at
this moment in time.
Tim
David Bakhash <·····@alum.mit.edu> writes:
: language is, it won't get the audience and usage it deserves. Common
: Lisp is definitely the best designed language by a long way, and yet
I'm sure this is trodden ground, but from what I can tell, Scheme
may be an evolution of Common Lisp?
And Common Lisp doesn't have continuations.
Again, sorry for beating this bush for the millionth time, but I am really
trying to decide which of Lisp and Scheme is the best-designed language.
Any pointers to some serious articles on this subject are welcomed as well.
Terrence Monroe Brannon <········@oracle.com> writes:
> David Bakhash <·····@alum.mit.edu> writes:
>
> : language is, it won't get the audience and usage it deserves. Common
> : Lisp is definitely the best designed language by a long way, and yet
>
> I'm sure this is trodden ground, but from what I can tell, Scheme
> may be an evolution of Common Lisp?
As a point of history, Scheme predates CL. Also, as a point of history,
Guy Steele was one of two creators of Scheme, and was the author of the
original CL spec. It is therefore unlikely that he was not aware of Scheme.
CL drew what it wanted from Scheme and left behind what it did not.
> And Common Lisp doesn't have continuations.
That's right. It didn't want them. They are theoretically interesting
and no one probably knows this much better than Steele. But they are not
the answer to all the world's problems, nor are they without baggage.
> Again, sorry for beating this bush for the millionth time, but I am really
> trying to decide which of Lisp and Scheme is the best-designed language.
Languages are designed for a purpose. Different languages have different
purposes. Scheme was designed for teaching. It has, largely through
adding many proprietary extensions in some implementations, found a market.
But that market is very different than the CL market.
> Any pointers to some serious articles on this subject are welcomed as well.
This question is meaningless outside a context, though is a good way to get
people to write lots of frenzied text. You'd do as well to have a
meta-discussion of what makes a good language. But before you compare
languages, please at least figure out the purpose.
The adjectives "good" and "bad" (and their friend adverbs "well" and "poorly")
have no meaning absent a context.
Terrence Monroe Brannon wrote:
> David Bakhash <·····@alum.mit.edu> writes:
>
> : language is, it won't get the audience and usage it deserves. Common
> : Lisp is definitely the best designed language by a long way, and yet
>
> I'm sure this is trodden ground, but from what I can tell, Scheme
> may be an evolution of Common Lisp?
Since Common Lisp came _after_ Scheme and was somewhat influenced by it
sying that Scheme is an evolution of Common Lisp is a bit irrational IMHO.
> And Common Lisp doesn't have continuations.
So what?
Are continuations _so_ important that they have to be part of Common Lisp
to be competitive to Scheme? Have you ever thought that it could have been
the *intention* of the Common Lisp designers _not_ to include continuations?
Common Lisp has conditions and throw/catch in the standard and most
implementations have multithreading capabilities. So many of the things you
can do with continuations are there in more specialized, easier to handle
and understandable variants. Other things can be implemented in parts as
shown in Paul Grahams "On Lisp".
Much more a problem is IMHO that Scheme lacks multiple namespaces (Being a
Lisp1).
> Again, sorry for beating this bush for the millionth time, but I am really
> trying to decide which of Lisp and Scheme is the best-designed language.
"Best.designed" is like talking on "Good weather". If I want to go skying I
have another notion of "Good weather" than if I want to go swimming...
You "design" something with some goal in mind - if the goals for Scheme and
Common Lisp was different (which is IMHO true) then they are not comparable
in this way.
> Any pointers to some serious articles on this subject are welcomed as
> well.
You will certainly not find any serious articles on that topic.
Why do you need someone who is saying to you "Yes this language _is_ by any
means better than that language...". Try _both_ languages and come to your
own conclusion that fits what _you_ want to do with the language.
I personally have tried both and came to the conclusion that Common Lisp
enables *me* to write better programs in shorter time.
ciao,
Jochen
"Terrence Monroe Brannon" <········@oracle.com> wrote in message
·····················@ap555sun.us.oracle.com...
> [W]hich of Lisp and Scheme is the best-designed language.
Both are. Let me state the difference in slightly (but not very) exaggerated
terms.
The first sentence of the Introduction of the Scheme report states:
Programming languages should be designed
not by piling feature on top of feature,
but by removing the weaknesses and re-
strictions that make additional features
appear necessary.
That approach has lead to a (firly) minimal language, with few elements of
maximal power. Continuations are an obvious need in that context. Anything
that can be built from existing Scheme elements should not be part of Scheme
Common Lisp in certain ways is almost the opposite. If it is useful, add it in!
Which means that the question "How do I do ..?" has the standard answer "Use the
functionality specifically provided to do that". A Common Lisper doesn't want
to build anything starting from continuations - the language should directly
provide the things a Schemer would build.
Scheme is great for teaching, because if you don't understand the concepts you
cannot build a working program, and the number of things to learn is small.
(Scheme report, including formal syntax and semantics, is 50 pages.) Because
Scheme tries hard to be pure, it is also a good language for theoretical
research.
CL is great for application programming, because all the stuff you are likely to
need is already there, and you get a lot of leverage. Code from older Lisps
(esp. MacLisp) doesn't need a lot of change.
(EuLisp tries to be both: a small, clean, and powerful kernel, with layers of
functionality around it.)
--
Biep
Reply via http://www.biep.org
In article <················@ap555sun.us.oracle.com>,
Terrence Monroe Brannon <········@oracle.com> wrote:
>
>Again, sorry for beating this bush for the millionth time, but I am really
>trying to decide which of Lisp and Scheme is the best-designed language.
>
Both languages are very well-designed according to their design
goals (for that matter, I think the same of C++). I don't know
of a sufficiently precise way to measure how well-designed a
language is, for given goals, so I can't answer that question.
What I can tell you is that I like Common Lisp, and find its
design goals better suited for the sort of things I want to do
that don't involve large-scale multiplatform distribution.
--
David H. Thornley | If you want my opinion, ask.
·····@thornley.net | If you don't, flee.
http://www.thornley.net/~thornley/david/ | O-
>>>>> "TMB" == Terrence Monroe Brannon <········@oracle.com> writes:
TMB> Again, sorry for beating this bush for the millionth time,
TMB> but I am really trying to decide which of Lisp and Scheme is
TMB> the best-designed language.
Well, when you figure it out, please report back here. It'd be a real
shame if anyone went around using something that wasn't the very best
designed language ever invented.
Personally, I can't wait for your results, so we can FINALLY shut down
either comp.lang.lisp or comp.lang.scheme. They're taking up WAY too
much of my newsspool.
~ESP
--
Evan Prodromou
····@prodromou.san-francisco.ca.us