Scheme vs ML again and again and again and again 
Author Message
 Scheme vs ML again and again and again and again

I proposed a moratorium on discussions re ML vs Scheme and static
vs dynamic typing (which, to answer one question someone asked, are
related topics, but not the same).

This would be voluntary (not that there's much alternative on usenet),
so we needn't see it as a threat to free speech.

There will, of course, be people new to comp.lang.scheme who will
start or participate in such discussions.  Anyone who wants to might
try gently discouraging them.  A comprehensive and fair-to-both-sides
answer to these "FAQ"s might help too.

But in any case, the discussions would be much more likely to fade,
once started, if various long-time participants in comp.lang.scheme
would stay out of them.

That means that some people who, evidently, enjoy such discussions
(e.g., Matthias Blume and, often, before now, me) will have to
exercise some self-denial.  I hope that they will do so.

In any case, the discussions seem to be almost completely futile.
Misleading and and worse arguments and claims are answered, only to
reappear the next time the dispute starts as if the answer had never
been posted.  And then, of course, someone will want to correct the
misleading claims again, getting us back into this seemingly endless
cycle.

Can't we "just say `no'" and stop?

-- jd



Mon, 18 Jan 1999 03:00:00 GMT  
 Scheme vs ML again and again and again and again

Jeff has a point: a balanced FAQ would go a long way toward helping to
reduce the redundancy in this newsgroup, and would provide a simple
answer for many commonly occurring questions.

Why don't people like me "just say no"?  Because the issues aren't just
a matter of opinion.  If they were, it'd make sense to agree to
disagree.  But they're not, at least not in every case.  To take a
topical example, it's a Schemer's mantra that statically typed languages
are more restrictive than dynamically typed languages.  Yet the latter
are merely tiny subsets of the former: the claim is just plain false.
This is not a matter of opinion, it's a matter of fact.  To me it is
worth correcting --- perhaps repeatedly --- a persistent (I would almost
say willful) misunderstanding of this fundamental point.

Now if you ask whether round brackets are better than square brackets,
or whether prefix notation is better than mixfix notation, then, yes,
I'll just say "no".

Bob



Mon, 18 Jan 1999 03:00:00 GMT  
 Scheme vs ML again and again and again and again

   I proposed a moratorium on discussions re ML vs Scheme and static
   vs dynamic typing (which, to answer one question someone asked, are
   related topics, but not the same).

   This would be voluntary (not that there's much alternative on usenet),
   so we needn't see it as a threat to free speech.

   There will, of course, be people new to comp.lang.scheme who will
   start or participate in such discussions.  Anyone who wants to might
   try gently discouraging them.  A comprehensive and fair-to-both-sides
   answer to these "FAQ"s might help too.

   But in any case, the discussions would be much more likely to fade,
   once started, if various long-time participants in comp.lang.scheme
   would stay out of them.

   That means that some people who, evidently, enjoy such discussions
   (e.g., Matthias Blume and, often, before now, me) will have to
   exercise some self-denial.  I hope that they will do so.

   In any case, the discussions seem to be almost completely futile.
   Misleading and and worse arguments and claims are answered, only to
   reappear the next time the dispute starts as if the answer had never
   been posted.  And then, of course, someone will want to correct the
   misleading claims again, getting us back into this seemingly endless
   cycle.

   Can't we "just say `no'" and stop?

Perhaps.

The problem I see with this proposal is that such discussions don't
come up on their own, but are prompted by other, Scheme-related
questions.  For example, if someone asks about the why and how of
multiple values, then discussion will naturally go the following path:

        aren't multiple values ugly and unnecessary?
        why don't we use a first-class container value like a tuple?
        why do you think you can't optimize this cleverly enough?
        ah, so you mean you don't have the necessary global data flow
                information?
        what about a good static type system?
        I distinctively remember seeing the container-type solution
                somewhere else, and it worked there quite well...
        wasn't the language calles something like ML?
        ...

I guess you catch my drift.

Frankly, there isn't much interesting left to discuss if we want to
block out every mention of types.  So in order to comply with the
moratorium some of us will have to stop saying anything at all.  Not a
bad idea, I guess...

Regards,
--
-Matthias



Mon, 18 Jan 1999 03:00:00 GMT  
 Scheme vs ML again and again and again and again


Quote:

>Why don't people like me "just say no"?  Because the issues aren't just
>a matter of opinion.  If they were, it'd make sense to agree to
>disagree.  But they're not, at least not in every case.  To take a
>topical example, it's a Schemer's mantra that statically typed languages
>are more restrictive than dynamically typed languages.  Yet the latter
>are merely tiny subsets of the former: the claim is just plain false.
>This is not a matter of opinion, it's a matter of fact.  To me it is
>worth correcting --- perhaps repeatedly --- a persistent (I would almost
>say willful) misunderstanding of this fundamental point.

This willful and self-righteous tirade confuses conviction and fact,
confuses theory and application, and does little to advance your point.
Perhaps an actual statement of that point (so that it can enlighten the
apparently much confused and willful masses) would help.  It is true that
the type system of dynamically typed languages (unitype, etc.) can be
rperesented using a static type system.  This is the type theory, and a
basic knowledge of this fact is indeed important for those who care about
type systems at all.  However, it still remains a matter of (strong)
opinion as to which system is more *restrictive*.  Whether one considers a
type system restrictive or not has much to do with how one feels when one
attempts to sit down and write a program in it, and less to do with how
complete that type system is, and how 'tiny' of a subset of some other
type system it is.  It is therefore a productive argument to talk about
the pros and cons of various type systems, and how their completeness,
ease of use, restrictiveness, idioms, etc, affect programming.
Unfortunately, the debate is rarely held on that level.  The debate is too
often denigrated and confused by folks like yourself who cannot look at
the facts in more than one way.  I certainly know people who would claim
that the ML type system is but a tiny subset of the Scheme subsystem.
Remember that vigilance is the eternal price of liberty, and that we
almost never profit from proclaiming from a corner of self-righteousness
that all others must silence.  That is true even if you program in ML or
Scheme or Miranda or Haskell.  And especially true when you program in C++
:-)

Respectfully,

Sebastian



Tue, 19 Jan 1999 03:00:00 GMT  
 Scheme vs ML again and again and again and again

Quote:

>... it's a Schemer's mantra that statically typed languages
>are more restrictive than dynamically typed languages.  Yet the latter
>are merely tiny subsets of the former: the claim is just plain false.

Someone suggested writing a FAQ entry about this.  Let me suggest that
if so, it contain examples rather than just formal proof, and remember
that there are readers of comp.lang.scheme (me, for one) who have never
programmed in ML and whose experience of static typing is therefore
based on C/Pascal/fortran etc.  So when you say "you can just declare
everything to be of one universal type" an example would make that more
convincing -- that's certainly not the case in those other languages.

[Just in case it's not obvious, I'm not trying to justify people who
don't know ML bashing it!  I, for one, try to keep out of these debates;
instead I save my flaming for people who want to add ugly features to
Scheme just to make it compile more efficiently.  :-)  I'm just trying
to offer a helpful reminder that this proposed FAQ entry won't do its
job unless someone like me can understand it.]



Tue, 19 Jan 1999 03:00:00 GMT  
 Scheme vs ML again and again and again and again

[Sorry Jeff, but this subject is, at least for me, extremely interesting
and educational.  (And of course everybody likes the same things I do,
don't they?)]

Quote:

> [...]  To take a
> topical example, it's a Schemer's mantra that statically typed languages
> are more restrictive than dynamically typed languages.  Yet the latter
> are merely tiny subsets of the former: the claim is just plain false.

I was (correctly) chastised by you and others for stating that ML doesn't
instantiate separate instances of polymorphic functions on a per-type
basis.  This is a property of compilers, not the language.

I think you're making the same mistake when (it seems) you imply that a
type system only 'counts' when the compiler does it.  Type checking can be
done by macros.  Genuinely new semantics can be added to the language
using macros.

Scheme plus macros is more expressive than SML because Scheme plus macros
can be used to build new languages and language features in a way not
possible in SML.

This doesn't necessarily mean that strongly-typed languages are inherently
more restrictive than latently-typed languages, but it does say something
about a really good language extension mechanism.  And good language
extension mechanisms aren't (in theory anyway) limited to latently-typed
languages that use S-expressions (although it does make it easier).  See
"Extensibel Syntax with Lexical Scoping", (SRC Research Report 121;
February 21, 1994) by Luca Cardelli, Florian Matthes, and Martin Abadi.

-thant



Tue, 19 Jan 1999 03:00:00 GMT  
 Scheme vs ML again and again and again and again


   This willful and self-righteous tirade confuses conviction and fact,
   confuses theory and application, and does little to advance your point.

   [ ... ]

Whoa!

   [ ... ]  However, it still remains a matter of (strong)
   opinion as to which system is more *restrictive*.

It might be a matter of opinion (strong or not so strong), but it has
nothing to do with facts.  And that's exactly what Bob tried to
explain to you.

   [ ... ]  The debate is too
   often denigrated and confused by folks like yourself who cannot look at
   the facts in more than one way.

   [ ... ]

Whoa!  Watch out!

   Remember that vigilance is the eternal price of liberty, and that we
   almost never profit from proclaiming from a corner of self-righteousness
   that all others must silence.

Even the most liberal amongst ourselves are bound by facts, and
our vigilance should make sure that facts remain facts.

   [ ... ]

   Respectfully,

_Respect_fully?!?  What's your notion of respect?

   Sebastian

Personal advise: If you don't know what you are talking about, then at
least make sure you know who you are talking to.  You might spare
yourself embarassment like this in the future.

--
-Matthias



Tue, 19 Jan 1999 03:00:00 GMT  
 Scheme vs ML again and again and again and again

Quote:
> Date: Thu, 01 Aug 1996 21:24:44 -0400


> Jeff has a point: a balanced FAQ would go a long way toward helping to
> reduce the redundancy in this newsgroup, and would provide a simple
> answer for many commonly occurring questions.

There is, of course, already an FAQ posting which deals with a
number of questins and perhaps even this one.  (I haven't looked
recently.)

Quote:
> Why don't people like me "just say no"?  Because the issues aren't just
> a matter of opinion.

I don't think that matters very much.  If you think it doesn't make
sense to "agree to disagree", then don't agree to disagree: just stop.
Please.

Quote:
> If they were, it'd make sense to agree to
> disagree.  But they're not, at least not in every case.

BTW, if that's supposed to be an argument with the conclusion that
it does not make sense to agree to disagree, then it's not a valid
argument.  You have A -> B; not A; and from that you can't get not B.
(This is a minor point.)

Quote:
> To take a
> topical example, it's a Schemer's mantra that statically typed languages
> are more restrictive than dynamically typed languages.  Yet the latter
> are merely tiny subsets of the former: the claim is just plain false.

The "balanced FAQ" would probably say that your claim that they are
"tiny subsets" is somewhat misleading, especially if we depart from
Scheme (because Scheme doesn't let me define new types), and it
would explain why it was thought to be misleading.

But the "balanced FAQ" could make the "tiny subset" point in exactly
the way you think it should be made.  There would be something else
that said it was misleading, but that could be anticipated and
countered along with the "timy subset" claim.  So the FAQ could make
the point you want to make, and it could include counterarguments to
whatever Lisp-based reply was also in the FAQ.  From time to time,
you, or some other ML expert could suggest ways to improve the FAQ
discussion of this issue, or whatver.

I rather suspect that the FAQ entry would make your point better
than it's ever made in these repeated discussions (since at worst
it could begin life as the best of the comp.lang.scheme
presentations).

In addition, someone could provide a Scheme-in-ML module that
provided such things as Scheme-like I/O for Scheme objects as
they're represented in the Scheme-in-ML module.  This would
let Scheme fans try things for themselves with minimal effort
and would probably be much more convincing that these repeated
discussions ever are.

Quote:
> This is not a matter of opinion, it's a matter of fact.  To me it is
> worth correcting --- perhaps repeatedly --- a persistent (I would almost
> say willful) misunderstanding of this fundamental point.

The ML folk never change their tune either, not matter how many
times ...

But repeatedly making the point in comp.lang.scheme annoys many
and convinces virtually no one.  It might be OK of the discussion
come around much less frequently and lasted only (let's say) a day
or two.

Quote:
> Now if you ask whether round brackets are better than square brackets,
> or whether prefix notation is better than mixfix notation, then, yes,
> I'll just say "no".

Let me return to what I said in my 1st article:

  Let's just take it as given that both are good languages, that
  those who know one of them better than the other may not fully
  appreciate the virtures of the one they know less, and that
  such people may not even have their facts straight.

I still think we should all be able to agree to something like
that.  It says nothing about opinion, nor does it rely on anything
being opinion.

Now, if the people who already manage the comp.lang.scheme FAQ
don't want to deal with this issue in (roughly) the way I
suggested above (in which the ML folk get to have their case
presented the way they want to present it), I'll do it.
(I don't have any reason to feel that the comp.lang.scheme
FAQ maintainers _wouldn't_ want to do it.  I just want to make
it clear that it can happen even if, for whatever reason,
they don't.)

So maybe some on the ML side can get togteher and write
something.  If someone wants to reply for Scheme, that would
be cool too.  But let's do it mostly off-line rather than in
Comp.lang.scheme.

-- jd



Wed, 20 Jan 1999 03:00:00 GMT  
 Scheme vs ML again and again and again and again

I think it's worth setting down the story in the Scheme FAQ (which is
maintained, I think, by Mark Kantrowitz here at CMU, or at least was at one
time).  What exactly is the question that should be answered for the FAQ?

Bob



Wed, 20 Jan 1999 03:00:00 GMT  
 Scheme vs ML again and again and again and again


Quote:

>I don't think that matters very much.  If you think it doesn't make
>sense to "agree to disagree", then don't agree to disagree: just stop.
>Please.

I apologize to Jeff Dalton and others who are distressed by the Scheme
v. ML argument.  I was the one who started it.  In my defense, I
honestly didn't want a bunch of reheat-n-serve abstract arguments
about the respective language designs.  What I has hoped for was
testimonials from application developers that would highlight the
merits, and especially the failures, of each language.

For instance:
-----
"My name is Tom G., and I'm an ML-coholic.  I just finished
implementing a search library in ML.  The first thing I had to do was
spend N weeks writing support for parsing and processing
S-expressions.  It would have been easier in Scheme."

"My name is Rob H., and I'm a schemeaholic.  I first did Scheme when I
was writing an embedded language for a knowledge-based application,
and I thought that hygienic macros would be a great way to implement
it.  But then I discovered that I needed to do a lot of global
analysis to get acceptable performance.  I spent N weeks writing an
entire compiler front end for my language.  Macros are overrated; I
should have just done it in ML."

"MY NAME IS JEFF S., AND I'M A SCHEMEAHOLIC.  I SHORTED OUT MY
KEYBOARD SWEATING OVER A TYPE INFERENCER FOR SCHEME SO I COULD GET
ACCEPTABLE PERFORMANCE OUT OF MY NATURAL LANGUAGE RESEARCH CODE.  IF I
HAD JUST USED ML, MY CAPS LOCK KEY MIGHT STILL BE WORKING TODAY."
-----
I think a neutral FAQ covering Scheme v. ML would be very
useful.  I would hope that such testimonials might find their way into
it.

Again, I apologize for having asked an old, inflammatory question.
This time I'll ask a new, inflammatory question: why should a funding
agency keep supporting research on _two_ strict functional programming
languages, when the differences between the languages are apparently
so small, and the comparative experience with them is so meager, that
leading minds in the programming language community can't hold a civil
discussion about the relative merits of the languages for particular
classes of applications?

Just kidding :-)

Rob



Thu, 21 Jan 1999 03:00:00 GMT  
 
 [ 11 post ] 

 Relevant Pages 

1. Scheme vs ML again and again and again and again

2. Scheme vs ML again and again

3. static vs. dynamic typing (again, again)

4. APL and J (again and again) (long)

5. APL and J (again and again)

6. 'SQL Server Login': Again, again, ...

7. All in EXE file AGAIN AGAIN

8. trees again and again

9. Re-inventing hot water again and again

10. tcltest processes subdirectory again and again - Why?

11. Newsgroup access again, good to see you all again

12. How to make a command run again and again until it sees a certain pattern

 

 
Powered by phpBB® Forum Software