This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
language group. This puts Lisp at number 14 with a rating of .718%
We once again have an `A' (mainstream) language.
``Are you thinking what I'm thinking, Pinky?''
Joe Marshall <·········@alum.mit.edu> writes:
> This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
> language group. This puts Lisp at number 14 with a rating of .718%
>
> We once again have an `A' (mainstream) language.
Hey, I even get an honorable mention! What do I get for elevating Lisp
to an `A' language?
> ``Are you thinking what I'm thinking, Pinky?''
Yeah, but what're we gonna do now, Brain?
--
Duane Rettig ·····@franz.com Franz Inc. http://www.franz.com/
555 12th St., Suite 1450 http://www.555citycenter.com/
Oakland, Ca. 94607 Phone: (510) 452-2000; Fax: (510) 452-0182
In article <·············@franz.com>, Duane Rettig <·····@franz.com> wrote:
>Joe Marshall <·········@alum.mit.edu> writes:
>
>> This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
>> language group. This puts Lisp at number 14 with a rating of .718%
>>
>> We once again have an `A' (mainstream) language.
>
>Hey, I even get an honorable mention! What do I get for elevating Lisp
>to an `A' language?
Ah, so Scheme *is* a lisp for some purposes ;-).
Glad to be of help.
Brad
Bradley J Lucier wrote:
> In article <·············@franz.com>, Duane Rettig <·····@franz.com> wrote:
>
>>Joe Marshall <·········@alum.mit.edu> writes:
>>
>>
>>>This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
>>>language group. This puts Lisp at number 14 with a rating of .718%
>>>
>>>We once again have an `A' (mainstream) language.
>>
>>Hey, I even get an honorable mention! What do I get for elevating Lisp
>>to an `A' language?
>
>
> Ah, so Scheme *is* a lisp for some purposes ;-).
>
> Glad to be of help.
ROTFL
Pascal
--
OOPSLA'05 tutorial on generic functions & the CLOS Metaobject Protocol
++++ see http://p-cos.net/oopsla05-tutorial.html for more details ++++
Duane Rettig <·····@franz.com> writes:
> Joe Marshall <·········@alum.mit.edu> writes:
>
>> This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
>> language group. This puts Lisp at number 14 with a rating of .718%
>>
>> We once again have an `A' (mainstream) language.
>
> Hey, I even get an honorable mention! What do I get for elevating Lisp
> to an `A' language?
I believe that it is your paycheck, no?
>> ``Are you thinking what I'm thinking, Pinky?''
>
> Yeah, but what're we gonna do now, Brain?
Same thing we do every night, Pinky. Try to take over the world!
Joe Marshall <·········@alum.mit.edu> writes:
> This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
> language group. This puts Lisp at number 14 with a rating of .718%
>
Can anyone explain why Dylan is included in that group? It doesn't look
like a Lisp to me (at least syntax-wise). And the comp.lang.dylan
newsgroup seems to be dead, so not much help can be found there.
--
vedm
vedm <··@nospam.com> writes:
> Joe Marshall <·········@alum.mit.edu> writes:
>
>> This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
>> language group. This puts Lisp at number 14 with a rating of .718%
>>
>
> Can anyone explain why Dylan is included in that group? It doesn't look
> like a Lisp to me (at least syntax-wise). And the comp.lang.dylan
> newsgroup seems to be dead, so not much help can be found there.
Indeed. However, Dylan originally started out with two syntax
notations (sound familiar) and although I assume that the developers
always had it in mind to snuff out the paren-style syntax, the
availability originally of that lisp-like syntax was one of the
features that caused us (Franz Inc.) to look at possibly picking up
Dylan, when Apple was getting ready to dump it and invited us to
look at it. We looked, and saw the plans for dumping paren syntax,
as well as the lack (back then) of a good macro system, and decided
to pass.
That said, if you look past the syntax, Dylan is right in between
CL and Scheme, having borrowed enough from each to likely allow both
CLers and schemers to be comfortable with it. [Note that I said
"if you look past the syntax"; due to our ideas on what macros should
look like we decided that we coudn't look past the syntax]. So I
definitely consider Dylan to be a language in the Lisp family.
An argment could also be made to include Logo, but I didn't make it,
since I didn't want to stretch it too far.
--
Duane Rettig ·····@franz.com Franz Inc. http://www.franz.com/
555 12th St., Suite 1450 http://www.555citycenter.com/
Oakland, Ca. 94607 Phone: (510) 452-2000; Fax: (510) 452-0182
Hey Common Lisp is different languge from
Scheme , i don't want to speak about Dylan.
Alas if Tiobe groups Lisp/Scheme/Dylan
why don't they group VB and VB .Net
and Pascal and Delphi they are more alike each
other than Lisp\Scheme\Dylan are ?
At least that way comparation will be fair.
And why does A ( mainstream languages ) start from
No 13 instead of No 14 , just to make Lisp mainstream.
Compare :
http://www.developer.com/java/other/article.php/3455011
Jan 05
No 14
ABAP
A-
and
http://www.tiobe.com/tpci.htm
Sep 05
No 14
Lisp/Scheme /Dylan
A
This is plain cheating .
I like Lisp to be popular ,but no fabrications
like this PLEASE.
·············@hotmail.com writes:
> Hey Common Lisp is different languge from
> Scheme
Why do you say that?
, i don't want to speak about Dylan.
Why not?
> Alas if Tiobe groups Lisp/Scheme/Dylan
> why don't they group VB and VB .Net
> and Pascal and Delphi they are more alike each
> other than Lisp\Scheme\Dylan are ?
> At least that way comparation will be fair.
OK, make such comparisons/groupings. I have no problem with
that. In fact, the tiobe site says that they welcome such feedback,
and I have experienced that they seem to be responsive.
Note that I had never seen the tiobe site before Joe pointed it
out last month, and I certainly don't have any say in what
numbers come in for CL, Scheme, and Dylan.
> And why does A ( mainstream languages ) start from
> No 13 instead of No 14 , just to make Lisp mainstream.
> Compare :
> http://www.developer.com/java/other/article.php/3455011
> Jan 05
> No 14
> ABAP
> A-
> and
> http://www.tiobe.com/tpci.htm
> Sep 05
> No 14
> Lisp/Scheme /Dylan
> A
I don't know how they make their decision in categorizations.
However, if you notice from the comments below the chart (inspired
by the conversation I had with a tiobe developer) they _still_
don't analyze the numbers correctly; when they do their groupings
they only take the maximum hits for one language in the group.
This could explain the lower ranking, but the total hits might
be figured in to how they come up with the rating grade. I'm not
expecting to make good sense out of this difference until "very soon"
(as they put it) when hits for each language in a group will count
toward the overall rating.
> This is plain cheating
Tell me how. No numbers are fabricated, that I know of. You may
disagree with the grouping, but to call it cheating? That's pretty
offensive to those people who are putting in good efforts to gather
and analyze numbers. You might call the analysis wrong or incorrect,
and I'd accept it as your opinion and we simply disagree. But to
call it cheating presupposes an intent to hide truth. Perhaps
you've seen the truth hidden for so long that you don't recognize
it when you see it finally brought to light.
.
> I like Lisp to be popular ,but no fabrications
> like this PLEASE.
Tell me what is fabricated. But before you do, search google for
such topics as "is Scheme a Lisp?" and so on. You find yourself
hard-pressed to define what constitutes a Lisp, if you're honest
about your feelings, and if can separate the fact that you like a
particular kind of lisp from the definitions of what makes a Lisp.
--
Duane Rettig ·····@franz.com Franz Inc. http://www.franz.com/
555 12th St., Suite 1450 http://www.555citycenter.com/
Oakland, Ca. 94607 Phone: (510) 452-2000; Fax: (510) 452-0182
Duane Rettig wrote:
> ·············@hotmail.com writes:
>
> > Hey Common Lisp is different languge from
> > Scheme
>
> Why do you say that?
If we can't agree that Common Lisp is different programming
language from position of simple app programmer like me
i think we don't have anything else to discuss with .
For me definition is something like if i type Scheme in Allegro will
it compile ?
>
> , i don't want to speak about Dylan.
>
> Why not?
>
The real meaning was i don't EVEN want to speak about Dylan
because anything without s-expressions is not in Lisp family.
> > Alas if Tiobe groups Lisp/Scheme/Dylan
> > why don't they group VB and VB .Net
> > and Pascal and Delphi they are more alike each
> > other than Lisp\Scheme\Dylan are ?
> > At least that way comparation will be fair.
>
> OK, make such comparisons/groupings. I have no problem with
> that. In fact, the tiobe site says that they welcome such feedback,
> and I have experienced that they seem to be responsive.
> Note that I had never seen the tiobe site before Joe pointed it
> out last month, and I certainly don't have any say in what
> numbers come in for CL, Scheme, and Dylan.
>
The index measures programming languages popularity
not programming families , i know dialects a itchy to
define but Tiobe was doing it the right way till August.
And Common Lisp is not a dialect of Lisp it's language of
their own , so does Scheme and Dylan.
> > And why does A ( mainstream languages ) start from
> > No 13 instead of No 14 , just to make Lisp mainstream.
> > Compare :
> > http://www.developer.com/java/other/article.php/3455011
> > Jan 05
> > No 14
> > ABAP
> > A-
> > and
> > http://www.tiobe.com/tpci.htm
> > Sep 05
> > No 14
> > Lisp/Scheme /Dylan
> > A
>
> I don't know how they make their decision in categorizations.
> However, if you notice from the comments below the chart (inspired
> by the conversation I had with a tiobe developer) they _still_
> don't analyze the numbers correctly; when they do their groupings
> they only take the maximum hits for one language in the group.
> This could explain the lower ranking, but the total hits might
> be figured in to how they come up with the rating grade. I'm not
> expecting to make good sense out of this difference until "very soon"
> (as they put it) when hits for each language in a group will count
> toward the overall rating.
>
Looking on the 2004 indexes I think I'm probably wrong about
fabrication
of second case , my sincere apologies Tiobe.
(Though i disagree about low rated languages to be called mainstream,
much better for streight A would be top 5 languages .
even Python with much more market share is not qualified as mainstream
even by it's own programmers) And about Lisp being mainstream LOL.
Lisp is not mainstream i know it , you know , everybody knows it.
> But before you do, search google for
> such topics as "is Scheme a Lisp?" and so on. You find yourself
> hard-pressed to define what constitutes a Lisp, if you're honest
> about your feelings, and if can separate the fact that you like a
> particular kind of lisp from the definitions of what makes a Lisp.
I think we settled this ,for Joe average like me Common Lisp is all
i can write in my LW listener and get expectable return .
Common Lisp and Scheme are Lisp family language but Scheme is not
Common Lisp nor vice versa.
·············@hotmail.com writes:
> Duane Rettig wrote:
>> ·············@hotmail.com writes:
>>
>> > Hey Common Lisp is different languge from
>> > Scheme
>>
>> Why do you say that?
> If we can't agree that Common Lisp is different programming
> language from position of simple app programmer like me
> i think we don't have anything else to discuss with .
I'm not saying that they are the same language. Neither is Tiobe,
apparently. They seem to call it a language "grouping". This is not
the same as saying that two languages are the "same language".
> For me definition is something like if i type Scheme in Allegro will
> it compile ?
We're working with extensible languages here, so the answer is
of course "yes".
Let's work from the opposite end: In Allegro CL, I can type
(ff:def-foreign-call foo ())
and get a definition, which will run if there is a foreign entry
point named "foo" available. What happens when you type the same
thing in LW? or CMUCL? or ...? Does that means either Allegro CL
or LW/CMUCL/... are not Common Lisps? Of course not!
Let's continue: Ignoring packages for now, if in one of these
other Common Lisps I type
(defmacro def-foreign-call (<correct arglist>)
<correct definition>
and _then_ type (ff:def-foreign-call foo ()), would you expect it
to work then? Of course, given proper macro definition for the
extension. To see a complete set of definitions that bring different
implementations of Common Lisp together, you can look at UFFI or
any of the newer compatibility packages becoming available.
But so far, we're talking about two different implementations of
the same language. Note that just because they are the same
language doesn't mean that you can type exactly the same expressions
to each, even after macrology; there are some things that are not
defined by the language itself.
But what about typing scheme forms in lisp? What happens when you
type (+ 10 20) in a scheme and a CL? What about (lambda (x y) (* x y))?
There are a great number of commonalities between scheme and CL,
and for those expressions that can't be run in one or the other,
macros can usually be written that allow scheme-like programming
in CL and vice versa. Yes, there are some incompatibilities. And
I fall squarely in the CL camp when it comes to those. But to
say that these two languages don't belong in the same category
because they aren't the same language is ludicrous; of course they
aren't the same language; they are of the same language _family_.
>> , i don't want to speak about Dylan.
>>
>> Why not?
>>
> The real meaning was i don't EVEN want to speak about Dylan
> because anything without s-expressions is not in Lisp family.
OK; I respect that opinion. I share it to a certain extent, and
was one of the developers who rejected Dylan when Apple was trying
to get us to look at taking it on. But although I agree that Dylan
has lost a lot of its Lisp-ness, I don't agree that it makes it
not part of the Lisp family.
>> > Alas if Tiobe groups Lisp/Scheme/Dylan
>> > why don't they group VB and VB .Net
>> > and Pascal and Delphi they are more alike each
>> > other than Lisp\Scheme\Dylan are ?
>> > At least that way comparation will be fair.
>>
>> OK, make such comparisons/groupings. I have no problem with
>> that. In fact, the tiobe site says that they welcome such feedback,
>> and I have experienced that they seem to be responsive.
>> Note that I had never seen the tiobe site before Joe pointed it
>> out last month, and I certainly don't have any say in what
>> numbers come in for CL, Scheme, and Dylan.
>>
> The index measures programming languages popularity
> not programming families , i know dialects a itchy to
> define but Tiobe was doing it the right way till August.
> And Common Lisp is not a dialect of Lisp it's language of
> their own , so does Scheme and Dylan.
>> > And why does A ( mainstream languages ) start from
>> > No 13 instead of No 14 , just to make Lisp mainstream.
>> > Compare :
>> > http://www.developer.com/java/other/article.php/3455011
>> > Jan 05
>> > No 14
>> > ABAP
>> > A-
>> > and
>> > http://www.tiobe.com/tpci.htm
>> > Sep 05
>> > No 14
>> > Lisp/Scheme /Dylan
>> > A
>>
>> I don't know how they make their decision in categorizations.
>> However, if you notice from the comments below the chart (inspired
>> by the conversation I had with a tiobe developer) they _still_
>> don't analyze the numbers correctly; when they do their groupings
>> they only take the maximum hits for one language in the group.
>> This could explain the lower ranking, but the total hits might
>> be figured in to how they come up with the rating grade. I'm not
>> expecting to make good sense out of this difference until "very soon"
>> (as they put it) when hits for each language in a group will count
>> toward the overall rating.
>>
>
> Looking on the 2004 indexes I think I'm probably wrong about
> fabrication
> of second case , my sincere apologies Tiobe.
> (Though i disagree about low rated languages to be called mainstream,
> much better for streight A would be top 5 languages .
> even Python with much more market share is not qualified as mainstream
> even by it's own programmers) And about Lisp being mainstream LOL.
> Lisp is not mainstream i know it , you know , everybody knows it.
I don't know what it means to be "mainstream". To most people, in fact,
it really means to be on top. And only one langauge can be in that
position at a time. And I agree that Lisp is not "on top". So we
apparently agree.
>> But before you do, search google for
>> such topics as "is Scheme a Lisp?" and so on. You find yourself
>> hard-pressed to define what constitutes a Lisp, if you're honest
>> about your feelings, and if can separate the fact that you like a
>> particular kind of lisp from the definitions of what makes a Lisp.
>
> I think we settled this ,for Joe average like me Common Lisp is all
> i can write in my LW listener and get expectable return .
Modulo any implementation extensions or nonconformances...
> Common Lisp and Scheme are Lisp family language but Scheme is not
> Common Lisp nor vice versa.
Yes, of course that is true; it is not the question at hand, though.
Two languages do not have to be the same in order to be grouped
together (in fact, it is imperative that they indeed be different
languages in order to be called "two languages"). Tiobe are not
calling CL and Scheme the same; they are just grouping them together.
--
Duane Rettig ·····@franz.com Franz Inc. http://www.franz.com/
555 12th St., Suite 1450 http://www.555citycenter.com/
Oakland, Ca. 94607 Phone: (510) 452-2000; Fax: (510) 452-0182
On Wed, 07 Sep 2005 01:40:06 -0700, Duane Rettig <·····@franz.com> wrote:
> ·············@hotmail.com writes:
>
>> This is plain cheating
>
> Tell me how. No numbers are fabricated, that I know of. You may
> disagree with the grouping, but to call it cheating? That's pretty
> offensive to those people who are putting in good efforts to gather
> and analyze numbers.
Recommended reading:
Visual and Statistical Thinking: Displays of Evidence for Making Decisions
be Edward R. Tufte
ISBN 0-9613921-3-4
Quoting from page 13:
"Aggregations by area can sometimes mask and even distort the true
story of the data."
What I'd really like to see is an aggregation similar to the one done
by amazon.com, the "people who bought this book also bought" thing.
Don't press the data into prefabricated categories but let the data group itself.
s.
·········@gmail.com wrote:
> Indeed, the question is not whether Scheme is a Lisp, but whether
> Scheme and Common Lisp are the same language. If they are, then so are
> C and Java.
Good point the final list will look something like this:
1 C/C++/Java/C# 56.04 %
some notable remainings
2 Perl 9.27 %
3 PHP 8.90 %
4 VB/VB.net 7.17 %
5 Python 3.03 %
-----------------------------
Rest
Everybody who shares the same view that we should have
separate index for common lisp at Tiobe please sign :
http://www.petitiononline.com/comonlsp/petition.html
Ho do you set up a petition like this?
I would like to set up one that - correctly - separated all the "Scheme"
implementations. :)
BigLoo and MIT Scheme are not the same language :)
Cheers
--
Marco
fireblade wrote:
> Everybody who shares the same view that we should have
> separate index for common lisp at Tiobe please sign :
> http://www.petitiononline.com/comonlsp/petition.html
>
From: Christopher C. Stacy
Subject: Re: Petition for Common lisp separated
Date:
Message-ID: <uy868bzuj.fsf@news.dtpq.com>
Marco Antoniotti <·······@cs.nyu.edu> writes:
> Ho do you set up a petition like this?
>
> I would like to set up one that - correctly - separated all the
> "Scheme" implementations. :)
>
> BigLoo and MIT Scheme are not the same language :)
Neither are GCC and C.
From: Robert Maas, see http://tinyurl.com/uh3t
Subject: Re: Fabrication of Lisp rating
Date:
Message-ID: <REM-2005sep08-001@Yahoo.Com>
> From: ·············@hotmail.com
> 1 C/C++/Java/C# 56.04 %
> some notable remainings
> 2 Perl 9.27 %
> 3 PHP 8.90 %
> 4 VB/VB.net 7.17 %
> 5 Python 3.03 %
I would not group them that way at all. To me, having programmed in
Lisp for many years, and having gotten used to easily working with
large interlocking pointy structures, I find the presence or absence of
a garbage collector as the primary criterion of a language. A task that
is trivial in Lisp is virtually impossible in C unless you have
unlimited virtual memory and can live with *never* releasing blocks of
memory.
C++ is in a middle ground, whereby if you are careful to have only
strictly hierarchial structures, and never have pointers to the innerds
of any structure anybody else owns, and have all the correct ctors and
dtors, or alternately implement a reference count method in your copy
constructors and dtors, allowing shared structure but never allowing a
reference loop, then C++ is good enough.
So I would classify languages into four kingdoms:
(1) Lisp(CL/GEL/Scheme/PSL/etc.), Java, and other languages with full GC.
(2) C++ and other languages with only a ctor/copyctor/dtor system.
(3) C and other languages with only manual allocation and releasing of
memory blocks via built-in language features or standard library functions.
(4) Assembly language, Forth, and any other languages that have no built-in
memory allocate/release mechanism whatsoever, so you have to manually
call an OS trap/uuo/jsys/call/svc to allocate or release memory.
Then I'd sub-classify on subtler criteria within each kingdom.
The thing that makes Lisp special, within the full-GC-kingdom, is the
equivalence of data and program. There's a standard serialized format
(s-expressions), a standard deserializer/reader which produces internal
pointy structures, a standard serializer/printer, and furthermore for
internal pointy structures there's EVAL. Any full-GC language with this
program/data equivalence with all those standard utilities, I would
consider a "Lisp", and anything else I would not consider a "Lisp".
(I hope nobody minds me abbreviating Gnu Emacs Lisp as GEL?)
But note from the top: It's really meaningless to take votes on
aggregated quantities unless there's a law of the Universe that
requires aggregation in one particular way. Any quantity in first
place, except something in the majority, can be beaten simply by
lumping together everything else. Any quantity not in first place can
be put into first place by sub-dividing all larger quantities into
sufficiently small bits and pieces. For example, Apple Macintosh can be
put in first place by sub-dividing all installations of MicroSoft
Windows systems not just according to the particular version (2000, NT,
etc.) but also according to which of a thousand combinations of
virus-protection packages they have and any other nitpicking
differences we can identify. In fact if we consider two otherwise
identical MS-Windows systems to be different if they have different
sets of trojan worms running within them thereby causing them to behave
differently for identical user input, there might not be two identical
MS-W systems anywhere in the world. (That is surely an exaggeration,
but maybe not by much!)
P.S. The vast majority of animal species are arthropods, specifically
insects. So I guess we can say MicroSoft is like insects?
·······@Yahoo.Com (Robert Maas, see http://tinyurl.com/uh3t) writes:
> I hope nobody minds me abbreviating Gnu Emacs Lisp as GEL?
"GEL" is probably incomprehensible to most Lispers. The usual
abbreviation is "elisp".
·······@Yahoo.Com (Robert Maas, see http://tinyurl.com/uh3t) writes:
> So I would classify languages into four kingdoms:
> (1) Lisp(CL/GEL/Scheme/PSL/etc.), Java, and other languages with full GC.
> (2) C++ and other languages with only a ctor/copyctor/dtor system.
> (3) C and other languages with only manual allocation and releasing of
> memory blocks via built-in language features or standard library functions.
> (4) Assembly language, Forth, and any other languages that have no built-in
> memory allocate/release mechanism whatsoever, so you have to manually
> call an OS trap/uuo/jsys/call/svc to allocate or release memory.
What about C, C++ or Objective-C used with BoehmGC ?
And if you allocate dynamic memory in assembler calling _malloc
instead of trapping into the OS, you can even use it in assembler.
Oops, there remains only one kingdom.
--
__Pascal Bourguignon__ http://www.informatimago.com/
In deep sleep hear sound,
Cat vomit hairball somewhere.
Will find in morning.
·············@hotmail.com writes:
> Hey Common Lisp is different languge from
> Scheme , i don't want to speak about Dylan.
Except the (new) syntax Dylan is _very_ close to Common Lisp.
Regards,
--
Julian Stecklina
(Of course SML does have its weaknesses, but by comparison, a
discussion of C++'s strengths and flaws always sounds like an
argument about whether one should face north or east when one
is sacrificing one's goat to the rain god.) -- Thant Tessman
Duane Rettig <·····@franz.com> writes:
> vedm <··@nospam.com> writes:
> > Joe Marshall <·········@alum.mit.edu> writes:
> >> This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
> >> language group. This puts Lisp at number 14 with a rating of .718%
> > Can anyone explain why Dylan is included in that group? [...]
>
> [...] Dylan originally started out with two syntax notations [...]
> [Franz] looked, and saw the plans for dumping paren syntax, as well
> as the lack (back then) of a good macro system, and decided to pass.
>
> That said, if you look past the syntax, Dylan is right in between
> CL and Scheme, having borrowed enough from each to likely allow both
> CLers and schemers to be comfortable with it.
I agree with all of this summary stuff. I personally think of
original Dylan as more a member of the Lisp family than the later
stuff, since the move away from parens was also accompanied by a great
deal of loss of dynamicity (originally, I believe dylan = dynamic +
language). Compared to something like Java, I suppose, it was still
quite dynamic. But compared to most Lisp language family members,
Dylan was/is very static. And that trend seems to me to lose most of
what I personally see as the central part of Lisp... So, just as I often
tell people Scheme is not a Lisp, I would say the same of Dylan.
Then again, the late Prof. Bill Martin of MIT used to teach a course
in computational linguistics where he'd remark that among things in
the world, there are animals, vegetables, and minerals. And then
among animals there are people and there are animals. And then among
people there are civilized people and there are animals... So if you
see me sometimes acknowledging Dylan as a Lisp and sometimes not,
there is at least a proud linguistic basis for productively recycling
a label at multiple points in an ontology.
> [Note that I said "if you look past the syntax"; due to our ideas on
> what macros should look like we decided that we coudn't look past
> the syntax]. So I definitely consider Dylan to be a language in the
> Lisp family. An argment could also be made to include Logo, but I
> didn't make it, since I didn't want to stretch it too far.
Hey, this is Lisp we're talking about. It can survive a few dynamically
adapted labels...
This is nothing but artificial merger , i allready send the mail to
Tiobe asking them to separate Common Lisp rating.
Common Lisp is a far from mainstream language but this is no way to
change this.
Alex
···············@lycos.com writes:
> This is nothing but artificial merger , i allready send the mail to
> Tiobe asking them to separate Common Lisp rating.
> Common Lisp is a far from mainstream language but this is no way to
> change this.
Sour grapes. It's interesting that many people love Lisp, and wonder
why it doesn't seem to be popular - we discuss all kinds of ways to
look at data and perceptions, calling them lies. But now, when some
hard numbers are provided, some are crying "foul". I really don't
understand why people have _such_ a hard time seein Lisp succeed
in the popularity area once in a while.
Do you _really_ believe any other numbers you see on the net?
If so, why so, more than Lisp numbers?
--
Duane Rettig ·····@franz.com Franz Inc. http://www.franz.com/
555 12th St., Suite 1450 http://www.555citycenter.com/
Oakland, Ca. 94607 Phone: (510) 452-2000; Fax: (510) 452-0182
Duane Rettig wrote:
> ···············@lycos.com writes:
>
> > This is nothing but artificial merger , i allready send the mail to
> > Tiobe asking them to separate Common Lisp rating.
> > Common Lisp is a far from mainstream language but this is no way to
> > change this.
>
> Sour grapes. It's interesting that many people love Lisp, and wonder
> why it doesn't seem to be popular - we discuss all kinds of ways to
> look at data and perceptions, calling them lies. But now, when some
> hard numbers are provided, some are crying "foul". I really don't
> understand why people have _such_ a hard time seein Lisp succeed
> in the popularity area once in a while.
> Do you _really_ believe any other numbers you see on the net?
> If so, why so, more than Lisp numbers?
When i say that i want Lisp to be popular i mean Common Lisp ,
i left Scheme camp for years and I don't wanna go back .
I pushed very hard for Common Lisp being the language that students
will do their code on ,not Scheme so they could know how the real world
looks a like when they gratuate to know something else to code on
beside allmighty Java .
I'm perfectly aware that Common Lisp is marginalized, there's many
who
don't know that it even exists, and 95% of those who heard about it are
full of wrong missconceptions (slow ,interpreted AI language).
So Common Lisp , mainstream ? Please Give me a break .
I was slapped and made fun of so many times for using Common Lisp
that i still have fingers marked in my head .
But i didn't surrender . After I showed my roommates that i can code
my problems in Common Lisp and have a free weekend , while they were
struggling to finish on schedule with their buggy c , they wanted to
think about .
When i got my job i started with C++ , i fought hard to use Common Lisp
for prototyping , i fought to include few Lisp DLLs and i'll continue
untill i sow product written entirely in Common Lisp.
That's it the way we can do it . Create products with Lisp .
Software or service that will interest the world in Lisp just like
RoR draw people to Ruby .
Fabrication of ratings will do no good nor for language nor for the
community.
·········@gmail.com writes:
> Indeed, the question is not whether Scheme is a Lisp, but whether
> Scheme and Common Lisp are the same language.
Not at all. Two languages cannot be grouped together if they are the
same language - in that case they become the same language. In order
for two languages to be grouped together, it is necessary that the
languages indeed be two i.e. not the same language.
Nobody is arguing that Common Lisp and Scheme are the same language,
except for those who are setting up strawmen to knock down.
The question is indeed whether Scheme and Common Lisp (which are
at least two languages, and possibly even more) are of the same
language _family_ - i.e. that of Lisp.
--
Duane Rettig ·····@franz.com Franz Inc. http://www.franz.com/
555 12th St., Suite 1450 http://www.555citycenter.com/
Oakland, Ca. 94607 Phone: (510) 452-2000; Fax: (510) 452-0182
·········@gmail.com schrieb:
What the hell they are talking about ...
B8 00 B8 8E C0 BF 58 00 B8 41 B0 B9 1A 00 AB FE C0 E2 FB F1
That is a "macro". Sure, it is.
:)
···············@lycos.com writes:
> Duane Rettig wrote:
>> ···············@lycos.com writes:
>>
>> > This is nothing but artificial merger , i allready send the mail to
>> > Tiobe asking them to separate Common Lisp rating.
>> > Common Lisp is a far from mainstream language but this is no way to
>> > change this.
>>
>> Sour grapes. It's interesting that many people love Lisp, and wonder
>> why it doesn't seem to be popular - we discuss all kinds of ways to
>> look at data and perceptions, calling them lies. But now, when some
>> hard numbers are provided, some are crying "foul". I really don't
>> understand why people have _such_ a hard time seein Lisp succeed
>> in the popularity area once in a while.
>> Do you _really_ believe any other numbers you see on the net?
>> If so, why so, more than Lisp numbers?
>
> When i say that i want Lisp to be popular i mean Common Lisp ,
I am glad of this. I am of course rooting for Common Lisp more than
even you; I place my career and food on my table based on its success.
> i left Scheme camp for years and I don't wanna go back .
> I pushed very hard for Common Lisp being the language that students
> will do their code on ,not Scheme so they could know how the real world
> looks a like when they gratuate to know something else to code on
> beside allmighty Java .
A worthy goal.
> I'm perfectly aware that Common Lisp is marginalized, there's many
> who
> don't know that it even exists, and 95% of those who heard about it are
> full of wrong missconceptions (slow ,interpreted AI language).
> So Common Lisp , mainstream ? Please Give me a break .
> I was slapped and made fun of so many times for using Common Lisp
> that i still have fingers marked in my head .
> But i didn't surrender . After I showed my roommates that i can code
> my problems in Common Lisp and have a free weekend , while they were
> struggling to finish on schedule with their buggy c , they wanted to
> think about .
> When i got my job i started with C++ , i fought hard to use Common Lisp
> for prototyping , i fought to include few Lisp DLLs and i'll continue
> untill i sow product written entirely in Common Lisp.
> That's it the way we can do it . Create products with Lisp .
Even more accurately: Create products with Common Lisp. It is an
unfortunate fact that when I ask college graduates whether they learned
Lisp in college, many say "yes, I took a course in Scheme". And perhaps
they were turned off to Lisp in general, but it's not because they
learned something that was not Lisp; it is because they learned a
Lisp that is not practical for commercial applications. Scheme is
that lisp which tends not to be practical for commercial apps, and
Common Lisp is the lisp which tends to be practical in industry.
So we should leave the question of "whether lisp", and move on to
the question of "which lisp". Which lisp should we use? Common
Lisp, of course.
> Software or service that will interest the world in Lisp just like
> RoR draw people to Ruby .
Agreed.
> Fabrication of ratings will do no good nor for language nor for the
> community.
We disagree on whether Scheme and Common Lisp are of the same
family. Please show me what fabrication is occurring.
--
Duane Rettig ·····@franz.com Franz Inc. http://www.franz.com/
555 12th St., Suite 1450 http://www.555citycenter.com/
Oakland, Ca. 94607 Phone: (510) 452-2000; Fax: (510) 452-0182
Duane Rettig <·····@franz.com> writes:
> ···············@lycos.com writes:
> > Fabrication of ratings will do no good nor for language nor for the
> > community.
>
> We disagree on whether Scheme and Common Lisp are of the same
> family. Please show me what fabrication is occurring.
Given that we're talking about how to analyze some data, it doesn't
really matter whether either of you think that Scheme is really a Lisp
or not. The first question is, in the data being analyzed, can you
tell Scheme from Common Lisp from the Lisp family of languages? I
wasn't following this too closely, but I believe Duane's argument was
that "Common Lisp" shouldn't be seperated from "Lisp" because "Lisp"
is probably referring to CL. On the other hand, it could *also* be
referring to Scheme. Because there's no way to pull the two data
points apart, you pretty much have to throw them together, and
recognize the composite data point for what it is.
--
/|_ .-----------------------.
,' .\ / | Free Mumia Abu-Jamal! |
,--' _,' | Abolish the racist |
/ / | death penalty! |
( -. | `-----------------------'
| ) |
(`-. '--.)
`. )----'
Duane Rettig wrote:
> Even more accurately: Create products with Common Lisp. It is an
> unfortunate fact that when I ask college graduates whether they learned
> Lisp in college, many say "yes, I took a course in Scheme". And perhaps
> they were turned off to Lisp in general, but it's not because they
> learned something that was not Lisp; it is because they learned a
> Lisp that is not practical for commercial applications. Scheme is
It's not that much the "impractical", but more the educational focus.
I'm sure even a language with "nicer" syntax like ML or Haskell wouldn't
make more students use them, because it's all just recursion and list
processing to them (and lack of assignment to variables).
Most students simply don't know that lots of Lisp is just objects,
structs, hashtables, loops. They think recursion over lists, and
functional programming, and no side-effects.
> that lisp which tends not to be practical for commercial apps, and
> Common Lisp is the lisp which tends to be practical in industry.
> So we should leave the question of "whether lisp", and move on to
> the question of "which lisp". Which lisp should we use? Common
> Lisp, of course.
But the question "which Lisp" is easy, and it's often harder to decide
"whether Lisp", because it's not all about technology, but also
politics, what language your developers know, what the customers think
they want...
I mean, sure, I'd prefer Lisp over Java any day, but try to explain that
to a Java shop ;) (or even a software company that happens to use Java)
To be honest there are arguments for both sides.
--
My ideal for the future is to develop a filesystem remote interface
(a la Plan 9) and then have it implemented across the Internet as
the standard rather than HTML. That would be ultimate cool.
Ken Thompson
Ulrich Hobelmann <···········@web.de> writes:
> Duane Rettig wrote:
> > Even more accurately: Create products with Common Lisp. It is an
> > unfortunate fact that when I ask college graduates whether they learned
> > Lisp in college, many say "yes, I took a course in Scheme". And perhaps
> > they were turned off to Lisp in general, but it's not because they
> > learned something that was not Lisp; it is because they learned a
> > Lisp that is not practical for commercial applications. Scheme is
>
> It's not that much the "impractical", but more the educational
> focus. I'm sure even a language with "nicer" syntax like ML or Haskell
> wouldn't make more students use them, because it's all just recursion
> and list processing to them (and lack of assignment to variables).
>
> Most students simply don't know that lots of Lisp is just objects,
> structs, hashtables, loops. They think recursion over lists, and
> functional programming, and no side-effects.
>
> > that lisp which tends not to be practical for commercial apps, and
> > Common Lisp is the lisp which tends to be practical in industry.
> > So we should leave the question of "whether lisp", and move on to
> > the question of "which lisp". Which lisp should we use? Common
> > Lisp, of course.
>
> But the question "which Lisp" is easy, and it's often harder to decide
> "whether Lisp", because it's not all about technology, but also
> politics, what language your developers know, what the customers think
> they want...
>
> I mean, sure, I'd prefer Lisp over Java any day, but try to explain
> that to a Java shop ;) (or even a software company that happens to
> use Java)
>
> To be honest there are arguments for both sides.
>
The politics and FUD aspects seem to be the really hard ones to deal
with. For example, we have to deal with a rather flaky piece of
software at work. It is known that the core of the system was written
in Lisp and I have constant arguments because everyone else says it is
the lisp core which is the cause of the flakyness of the system. None
of this argument is based on any evidence or fact. I counter argue by
pointing out that in fact, the core of the product works perfectly,
its the very badly designed and implemented additional functionality
which is the problem - functionality which was added using C++
wrappers and a really 'dumb' C++ interface layer. I can provide clear
evidence to prove this, but still everyone prefers to believe its the
lisp part.
I recently had an argument with a vendor who was proposing a Java
based solution for us. I wasn't even trying to push a lisp
solution. However, the lead developer from the vendor heard I liked
lisp and in a very dismissive way sneered and said "lets see you solve
an inherently procedural problem with lisp". to be honest, I couldn't
be bothered arguing the point as I could instantly tell his
understanding and knowledge of Lisp was so poor that I wasn't going to
change anything in a conversation over lunch.
I believe the only way we will ever change this perception is with
genuine runs on the board - we need to get more success stories -
especially ones in which relatively small shops are able to
effectively compete with bigger outfits or establish a new benchmark
in a field through the use of lisp. Without that, we are unlikely to
progress past academic arguments of x versus y.
Tim
--
Tim Cross
The e-mail address on this message is FALSE (obviously!). My real e-mail is
to a company in Australia called rapttech and my login is tcross - if you
really need to send mail, you should be able to work it out!
···············@lycos.com writes:
> This is nothing but artificial merger , i allready send the mail to
> Tiobe asking them to separate Common Lisp rating.
> Common Lisp is a far from mainstream language but this is no way to
> change this.
The level of argument this has produced is amazing. We spend so much
time in this group griping that lisp isn't popular, you'd think that
the moment someone says it is we'd be jumping for joy.
Tiobe measures Google hits! This may have some relationship to
language popularity, but it's hardly a scientific measure. Why is .7%
the magic cutoff between `A' and 'B' languages? Do you think there's
a remote chance that any pointy-haired manager would actually say
``Hmmm, I guess we'll let you use Lisp on this project.''?
~jrm
Joe Marshall wrote:
> ···············@lycos.com writes:
> > This is nothing but artificial merger , i allready send the mail to
> > Tiobe asking them to separate Common Lisp rating.
> > Common Lisp is a far from mainstream language but this is no way to
> > change this.
>
> The level of argument this has produced is amazing. We spend so much
> time in this group griping that lisp isn't popular, you'd think that
> the moment someone says it is we'd be jumping for joy.
I think it's healthy for people to voice their strong concerns. At
first, I also thought this rating was very misleading.
However, I've come to think that there's nothing "under the table"
about this comparison; it makes clear what the ratings are, and anyone
vaguely contemplating using Common Lisp can see that Scheme and Dylan
are listed.
The desire to know programming language popularity is a nontechnical
desire.
Tayssir
Kent M Pitman wrote:
> Duane Rettig <·····@franz.com> writes:
>
>
>>vedm <··@nospam.com> writes:
>>
>>>Joe Marshall <·········@alum.mit.edu> writes:
>>>
>>>>This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
>>>>language group. This puts Lisp at number 14 with a rating of .718%
>>>
>>>Can anyone explain why Dylan is included in that group? [...]
>>
>>[...] Dylan originally started out with two syntax notations [...]
>>[Franz] looked, and saw the plans for dumping paren syntax, as well
>>as the lack (back then) of a good macro system, and decided to pass.
>>
>>That said, if you look past the syntax, Dylan is right in between
>>CL and Scheme, having borrowed enough from each to likely allow both
>>CLers and schemers to be comfortable with it.
>
>
> I agree with all of this summary stuff. I personally think of
> original Dylan as more a member of the Lisp family than the later
> stuff, since the move away from parens was also accompanied by a great
> deal of loss of dynamicity (originally, I believe dylan = dynamic +
> language). Compared to something like Java, I suppose, it was still
> quite dynamic. But compared to most Lisp language family members,
> Dylan was/is very static. And that trend seems to me to lose most of
> what I personally see as the central part of Lisp... So, just as I often
> tell people Scheme is not a Lisp, I would say the same of Dylan.
Dylan actually started out with just one syntax, and it was the familiar
parenthesized syntax of Lisp. It was originally called "Ralph" (how it
got the name "Dylan" is a story that still amuses me), and its initial
implementation was as a CPS compiler that took Dylan source as input and
produced ARM code as output; that compiler was embedded in a version of
MCL called "leibniz", which supported two compilers and two sets of
listeners (the familiar MCL Common Lisp compiler and listeners, and the
Ralph compiler and listeners, which executed code on an ARM
daughterboard in a Nubus slot on suitable Macs).
The language at that time was basically a subset of Scheme extended with
a subset of CLOS, with all data types made properly instances of
classes, with certain old, familiar names replaced with new ones deemed
to be less opaque ("lambda"-->"method", "let"-->"bind", and so on), and
with some additions, such as singletons and currying and a few other things.
Some of the dynamic features of Common Lisp were consciously omitted to
make it easier to separate the development environment from the
delivered executable. This seemed like a more appealing idea then than
it may now, in part, perhaps, because it was being used to write an
operating system that was supposed to fit in a machine whose total
storage was expected to be 512K (that's RAM, but RAM was all it was
expected to have).
The designers and implementors were Lisp folks (in fact, were
substantially the folks who implemented MCL, plus a few others, notably
David Moon and Kim Barrett and Jeff Piazza). They went out of their way
to accommodate non-Lispers, holding many design meetings and soliciting
lots of input. Dylan was part of a project that was meant to produce a
new dynamic programming language suitable for the many projects that
Apple used to fund in its (now defunct) Advanced Technology Group. The
managers of that project wanted to attract Smalltalk folks and other
programmers to use the new language, and so tried to get them to say
what they wanted.
One thing they said over and over that they wanted was a syntax that was
not so darn Lispy. So eventually the designers and implementors said,
sure, we can do that. Give us some time to design one that can do all
the things we think the language needs to be able to do. We'll add a
front end that can understand that syntax you are asking for and people
who like that syntax can use it, and people who like the Lispy syntax
can use that. That sounded eminently reasonable to me (I used to sit at
the table in these meetings).
In hindsight, I think I was wrong. I think the infix syntax was a bad
idea. It didn't persuade people to flock to the language, and of course
when it was implemented the original Lispy syntax was abandoned.
I worked for a couple of years on the OS project, and to this day,
Ralph, that early version of Dylan, is my favorite programming language.
I don't care for the later, infix version, though. Ralph seemed terse,
elegant, and natural. Present-day Dylan seems none of those things to me.
vedm wrote:
> Joe Marshall <·········@alum.mit.edu> writes:
>
>
>>This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
>>language group. This puts Lisp at number 14 with a rating of .718%
>>
>
>
> Can anyone explain why Dylan is included in that group? It doesn't look
> like a Lisp to me (at least syntax-wise). And the comp.lang.dylan
> newsgroup seems to be dead, so not much help can be found there.
>
>
From an old Dylan FAQ:
Dylan is a new Object Oriented Dynamic Language (OODL), developed by the
Eastern Research and Technology Lab of Apple Computer. Dylan was
designed to make the advantages of OODLs available for commercial
programming on a variety of computing devices. Dylan most closely
~~~~~~~~~~~~~~~~~~
resembles CLOS and Scheme. Other languages which influenced the design
~~~~~~~~~~~~~~~~~~~~~~~~~
of Dylan include Smalltalk, Self, and OakLisp.
So no, it doesn't *look* like a lisp -- but it (well, to a certain
extent) behaves (behaved?) /something/ like one.
HTH,
--ag
--
Artie Gold -- Austin, Texas
http://goldsays.blogspot.com (new post 8/5)
http://www.cafepress.com/goldsays
"If you have nothing to hide, you're not trying!"
vedm wrote:
> Joe Marshall <·········@alum.mit.edu> writes:
>
>
>>This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
>>language group. This puts Lisp at number 14 with a rating of .718%
>>
>
>
> Can anyone explain why Dylan is included in that group? It doesn't look
> like a Lisp to me (at least syntax-wise). And the comp.lang.dylan
> newsgroup seems to be dead, so not much help can be found there.
>
I think I'd agree. Dylan started out being much more lispy
than its later (and current) versions are. It doesn't have
macros that operate directly on the parse tree, and its code
doesn't have any form where it can be read as or manipulated
as data. It isn't a lisp anymore.
On the other hand, Common Lisp and Scheme are both clearly
lisps, and for purposes of this survey probably should be
grouped.
Bear
vedm wrote:
> Joe Marshall <·········@alum.mit.edu> writes:
>
>>This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
>>language group. This puts Lisp at number 14 with a rating of .718%
>
> Can anyone explain why Dylan is included in that group? It doesn't look
> like a Lisp to me (at least syntax-wise). And the comp.lang.dylan
> newsgroup seems to be dead, so not much help can be found there.
"I'm trying to find a way of looking at it that means we get to eat them."
(Douglas Adams, 'The Hitch-Hiker's Guide to the Galaxy', quoted from
memory so may not be verbatim.)
--
"Always look on the bright side of life."
To reply by email, replace no.spam with my last name.
Joe Marshall wrote:
>
> ``Are you thinking what I'm thinking, Pinky?''
I think so Brain, but where will we find all the latex and gasoline?
drewc
--
Drew Crampsie
drewc at tech dot coop
"Never mind the bollocks -- here's the sexp's tools."
-- Karl A. Krueger on comp.lang.lisp
Joe Marshall <·········@alum.mit.edu> writes:
> This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
> language group. This puts Lisp at number 14 with a rating of .718%
>
> We once again have an `A' (mainstream) language.
>
> ``Are you thinking what I'm thinking, Pinky?''
I think so, but the burlap does chafe my tail recursions so...
Joe Marshall <·········@alum.mit.edu> writes:
> This month, Tiobe has aggregated Lisp, Scheme, and Dylan into a single
> language group. This puts Lisp at number 14 with a rating of .718%
>
> We once again have an `A' (mainstream) language.
Hah! Whose evil plan was that?
> ``Are you thinking what I'm thinking, Pinky?''
Uh... yeah, Brain, but where are we going to find rubber pants our size?
--
(espen)