David Rush wrote:
>
> You know I think that this thread has so far set a comp.lang.* record for
> civilitiy in the face of a massively cross-posted language comparison
> thread. I was even wondering if it was going to die a quiet death, too.
>
When cross-posting, people try to be more responsible, avoiding
making incorrect claims that will not be tolerated by the larger
reader community (like Python is very slow, C is inherently
insecure, Lispers are stupid, etc.) That's why there are usually
more balanced and less bigoted opinions expressed in such threads.
Also, I think cross-posting benefits creative people. E.g.
I noticed that the recent thread "Python syntax in Lisp and
Scheme" tought many Pythonistas and Haskellers about macros,
while many Lispers learned about "yield" and that the
usual examples of macros like UNWIND-PROTECT and its
friend WITH-OPEN-FILE do not have to be macros at all,
if your fingers can manage to type the magic 6 letters.
(OK, the syntax is better without those magic letters, but
it's the only difference. If you want to demostrate the real
power of macros, show code introspection.)
If you only program from 9 to 5, and it's 2 months till your
retirement, and you think you don't need such exposure to new
ideas from other language groups, it's best you killfile
all crossposted articles, or whatever, just don't whine.
OTOH, such idea exposure could have prevented such big
mistakes like C#, Mozart/Oz, XML++, ARC and others.
·······@ziplip.com wrote:
> OTOH, such idea exposure could have prevented such big
> mistakes like C#, Mozart/Oz, XML++, ARC and others.
Having been exposed to C# and Mozart/Oz: what mistakes do you see in
these languages?
Regards,
Jo
>>>>> "mike420" == mike420 <·······@ziplip.com> writes:
mike420> C is inherently insecure
Surely we can agree on this being a fact.
;-)
------------------------+-----------------------------------------------------
Christian Lynbech | christian ··@ defun #\. dk
------------------------+-----------------------------------------------------
Hit the philistines three times over the head with the Elisp reference manual.
- ·······@hal.com (Michael A. Petonic)
·······@ziplip.com wrote:
...
> When cross-posting, people try to be more responsible, avoiding
My general Usenet experience says otherwise, actually.
> while many Lispers learned about "yield" and that the
> usual examples of macros like UNWIND-PROTECT and its
> friend WITH-OPEN-FILE do not have to be macros at all,
> if your fingers can manage to type the magic 6 letters.
Hmmm, which ones? Not 'yield' -- those are just FIVE...
> OTOH, such idea exposure could have prevented such big
> mistakes like C#, Mozart/Oz, XML++, ARC and others.
You think Paul Graham's ARC is "a big mistake"? Why,
specifically? What specific criticisms are you leveling
at it? And why do you think Graham was lacking in "idea
exposure"? I'm not saying I agree with the underlying
design decisions &c, but I don't understand your point.
I would be curious about just the same questions on
Mozart/Oz, too (which also has the advantage that you
can dowload it and play with it). What's so "bigly
mistaken" about it? Why do you think the researchers
from all over Europe who built it were suffering from
lack of "idea exposure"?
(( C# is basically just a competitive commercial move
against Java and shares most of the latter's defects --
but, again, "lack of idea exposure" doesn't seem to
apply; as for XML++, wasn't it just a research project
to enrich XML with "semantical descriptions"...? ))
Alex
From: Grzegorz =?UTF-8?B?Q2hydXBhxYJh?=
Subject: Re: Cross-posting is good
Date:
Message-ID: <bm72ne$jb5$1@news.ya.com>
Alex Martelli wrote:
> ·······@ziplip.com wrote:
> ...
>> When cross-posting, people try to be more responsible, avoiding
>
> My general Usenet experience says otherwise, actually.
>
>> while many Lispers learned about "yield" and that the
>> usual examples of macros like UNWIND-PROTECT and its
>> friend WITH-OPEN-FILE do not have to be macros at all,
>> if your fingers can manage to type the magic 6 letters.
>
> Hmmm, which ones? Not 'yield' -- those are just FIVE...
>
He must be meaning l-a-m-b-d-a.
>> OTOH, such idea exposure could have prevented such big
>> mistakes like C#, Mozart/Oz, XML++, ARC and others.
[snip]
> I would be curious about just the same questions on
> Mozart/Oz, too (which also has the advantage that you
> can dowload it and play with it). What's so "bigly
> mistaken" about it? Why do you think the researchers
> from all over Europe who built it were suffering from
> lack of "idea exposure"?
I would be curious too. This guy definitely knows how to build up
suspense...
--
Grzegorz
> (( C# is basically just a competitive commercial move
> against Java and shares most of the latter's defects --
> but, again, "lack of idea exposure" doesn't seem to
> apply; as for XML++, wasn't it just a research project
> to enrich XML with "semantical descriptions"...? ))
What defective features does C# have in your opinion?
I know C# very well and i cannot find any.
I think C# is by far the best programming language that i know of
(I know basic/pascal/c++/php/asm).
The only thing that is wrong with C# is that is is from Microsoft. Honestly.
--
cody
[Freeware, Games and Humor]
www.deutronium.de.vu || www.deutronium.tk
On Sun, 12 Oct 2003 22:23:27 +0200, "cody" <·······················@gmx.de> wrote:
> I think C# is by far the best programming language that i know of (I
> know basic/pascal/c++/php/asm).
That's not much.
You might want to read the answer to question 16 at
<http://slashdot.org/interviews/01/11/13/0420226.shtml>
Edi.
From: ·············@comcast.net
Subject: Re: Cross-posting is good
Date:
Message-ID: <oewm2i75.fsf@comcast.net>
"cody" <·······················@gmx.de> writes:
>> (( C# is basically just a competitive commercial move
>> against Java and shares most of the latter's defects --
>> but, again, "lack of idea exposure" doesn't seem to
>> apply; as for XML++, wasn't it just a research project
>> to enrich XML with "semantical descriptions"...? ))
>
>
> What defective features does C# have in your opinion?
Single dispatch, single inheritance, dichotomy between values and
objects, required type declarations, first-class methods (delegates)
not integrated into the syntax, security model breaks tail recursion,
difficult to parse syntax, etc. etc.
This is not really Lisp related. Only as far as programming language
discussions go, and we like talking about misfeatures and defects of
other "modern" and "advanced" programming languages, don't we? :)
"cody" <·······················@gmx.de> writes:
> > (( C# is basically just a competitive commercial move
> > against Java and shares most of the latter's defects --
> > but, again, "lack of idea exposure" doesn't seem to
> > apply; as for XML++, wasn't it just a research project
> > to enrich XML with "semantical descriptions"...? ))
>
> What defective features does C# have in your opinion?
> I know C# very well and i cannot find any.
Just a few, off the top of my head. If I had put them down somewhere,
there would be a *big* list. But I try to think about this stuff as
little as I can.
Take structs, for example. Hear how C# is better than Java because
"intrinsic" (value) types act like reference types through the
"revolutionary" (called this way by Tom Archer in "Inside C#",
Microsoft itself is only hyping about it) technology called
"boxing/unboxing". In Java one cannot pass an "int" to a method that
expects "object". In C# one can, because it will be automatically
boxed. Nice try, that. But I still can't store null's where I want.
Take DateTime type, for instance. If you have a member of this type,
it always has to contain a DateTime value. You cannot store anything
else in there, null being the first candidate of what I would want to
store there. One must invent some special date being a "no particular
date". That's why many value types have some notion of "null" value.
There's even a INullable interface. But only a fraction of value
types implement it. And "null" itself does not implement this
interface, so I cannot use ((INullable) var).IsNull test on
everything, too. It would annoy me to no end to use this consturct
everywhere when in lisp I can use just var, but at least it would be
doable.
And "null" is not false. Very annoying.
But the first I think should be the lack of optional arguments. Not
even talking about named ones. This really gets on my nerves.
And you must have heard of stupid libraries. My favorite recent
discovery being the Remove method of IList interface. It's so funny I
even remember it! The method signature is this:
void Remove(object value);
Looks ok to you doesn't it? Except that one does not have a way to
know if anything was actually removed! It would not matter if it
removed all occurances of object from the list. But it removes only
the first one! How hard would it be for this method to return either
a boolean or the removed object?
If you want more, use Google. There's lots for you to discover.
--
Janis Dzerins
Common Lisp -- you get more than what you see.
Janis Dzerins wrote:
> This is not really Lisp related. Only as far as programming language
> discussions go, and we like talking about misfeatures and defects of
> other "modern" and "advanced" programming languages, don't we? :)
>
> "cody" <·······················@gmx.de> writes:
>
>>What defective features does C# have in your opinion?
>>I know C# very well and i cannot find any.
>
>
> Just a few, off the top of my head. If I had put them down somewhere,
> there would be a *big* list. But I try to think about this stuff as
> little as I can.
>
> Take structs, for example. Hear how C# is better than Java because
> "intrinsic" (value) types act like reference types through the
> "revolutionary" (called this way by Tom Archer in "Inside C#",
> Microsoft itself is only hyping about it) technology called
> "boxing/unboxing". In Java one cannot pass an "int" to a method that
> expects "object". In C# one can, because it will be automatically
> boxed. Nice try, that. But I still can't store null's where I want.
Well, Java is going to add that "feature" as well.
Anyway, the really ironic stupidity wrt boxing/unboxing is that primitve
types have allegedly been included in Java and C# because of efficiency
reasons.
Now imagine a program that permanently boxes and unboxes values. How
efficient is that? ;)
(I don't have any statistical data to back my claim, so I might be wrong
and permanent boxing/unboxing might not occur in real-world programs.
But it's a fact that languages of the Lisp heritage - including, for
example, Smalltalk - have a much better solution for this since decades.)
Pascal
--
Pascal Costanza University of Bonn
···············@web.de Institute of Computer Science III
http://www.pascalcostanza.de R�merstr. 164, D-53117 Bonn (Germany)