[plt-scheme] Re: One eyed man leads blind

On Thu, 10 Dec 2009 22:06:34 -0500, Stephen Bloch
<sbloch at adelphi.edu> wrote:

>
>On Dec 10, 2009, at 5:09 PM, wooks wrote:
>
>> So it looks like I'll be teaching a course in Programming Paradigms
>> next term/semester. I never actually took a course in the subject
>> myself and have varying degrees of familiarity with the main
>> paradigms. Life is going to get very interesting.
>> 
>> There are a number of recommended texts none of which I am familiar
>> with, one of which is Mitchell's Concepts of Programming Languages.
>> 
>>
http://www.amazon.com/Concepts-Programming-Languages-John-Mitchell/dp/0521780985/ref=sr_1_1?ie=UTF8&s=books&qid=1260482563&sr
=8-1
>
>I don't know this one.
>
>You might take a look at <a href="http://www.info.ucl.ac.be/~pvr/book.html">van Roy and Haridi</a>, about which I've heard
good things (although I haven't used it in a class myself).  

>In particular, van Roy and Haridi don't believe there is such a thing as a "programming paradigm", only features that
various languages provide or don't (an opinion that people on this list have also expressed).

Really?  According to the Preface of a June 5, 2003, draft version of
CTM (see
http://www.ulb.ac.be/di/rwuyts/INFO020_2003/vanRoyHaridi2003-book.pdf),
van Roy and Haridi write as follows:

>The term computation model makes precise the imprecise notion of
>“programming paradigm”. The rest of the book talks about computation models
>and not programming paradigms.

Therefore, they claim to seek to make precise the notion of a
"programming paradigm" by using a "computation model."  However, this
is not the same as if they "don't believe there is such a thing as a
'programming paradigm'"; they merely believe that programming
paradigms are "imprecise" and unsuitable for their exposition.

Further, according to page 108:

>One research goal of the Oz project is to
>explore what programming techniques are possible in a computation model that
>integrates several programming paradigms. The only way to achieve this goal is
>with dynamic typing.

Therefore, their "computation model integrates several programming
paradigms," which is not possible unless they believe that there is
such a thing as a "programming paradigm"; they just don't work with
such paradigms, because they consider them not precise enough for
their treatment.  Instead, they work with a "computation model."  But
this is not the same as claiming that a programming paradigm doesn't
exist; they just don't use one because they don't believe that the
notion is suitable.

>To prove this, they do everything in the language Oz, which allegedly 
>provides all the features necessary to do procedural, OO, functional, 
>logical/declarative, concurrent, multi-agent, etc. programming, tightly 
>integrated so you don't think of your programming as being in any one 
>particular "paradigm".  Implementations of Oz are available for free 
>download (look for Mozart).

The reason that they do everything in the language Oz is that they
believe that the notion of a "programming paradigm" is "imprecise,"
not that they "don't believe there is such a thing."  Believing that
something is unsuitable and believing that it doesn't exist are two
different things; it is possible to believe that something exists
without agreeing with it.

In fact, in the chapter "Programming Paradigms for Dummies: What Every
Programmer Should Know" (see
http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf) (2009), on page 2,
one of the same authors, van Roy, writes as follows:

>A programming paradigm is an
>approach to programming a computer based on a mathematical theory or a coherent set of
>principles. Each paradigm supports a set of concepts that makes it the best for a certain
>kind of problem. For example, object-oriented programming is best for problems with a
>large number of related data abstractions organized in a hierarchy. Logic programming
>is best for transforming or navigating complex symbolic structures according to logical
>rules. Discrete synchronous programming is best for reactive problems, i.e., problems
>that consist of reactions to sequences of external events. Languages that support these
>three paradigms are respectively Java, Prolog, and Esterel.

On page 1, he even writes:

>We give a taxonomy of almost 30 useful programming paradigms and how they are related.

How can one give a taxonomy of something that one believes doesn't
exist?  One can, however, disagree with the notion of a "paradigm"
while defining it, however.

You are probably misinterpreting van Roy's views in view of Shriram
Krishnamurthi's views as expressed in his paper "Teaching Programming
Languages in a Post-Linnaean Age" (see
http://www.cs.brown.edu/~sk/Publications/Papers/Published/sk-teach-pl-post-linnaean/paper.pdf),
in which Krishnamurthi argues as follows (in the Abstract):

>Programming language “paradigms” are a moribund and tedious legacy of a bygone age. Modern language
>designers pay them no respect, so why do our courses slavishly adhere to them? This paper argues that we
>should abandon this method of teaching languages, offers an alternative, reconciles an important split in
>programming language education, and describes a textbook that explores these matters.

In particular, Krishnamurthi writes (on page 1):

>Most books
>rigorously adhere to the sacred division of languages into “functional”, “imperative”, “object-oriented”,
>and “logic” camps. I conjecture that this desire for taxonomy is an artifact of our science-envy from the
>early days of our discipline: a misguided attempt to follow the practice of science rather than its spirit.

Hence, Krishnamurthi explicitly rejects the notion of a taxonomy of
programming language paradigms as a "misguided attempt."  Instead, he
believes in programming languages as "aggregations of features" (see
page 2), as follows:

>If languages are not defined by taxonomies, how are they constructed? They are aggregations of features.
>Rather than study extant languages as a whole, which conflates the essential with the accidental, it is more
>instructive to decompose them into constituent features, which in turn can be studied individually. The
>student then has a toolkit of features that they can re-compose per their needs.

Hence, van Roy and Krishnamurthi have different approaches to
approaching classifications of programming languages.  It is
Krishnamurthi, not van Roy, who argues that there are "only features
that various languages provide or don't."  Van Roy doesn't like the
notion of a "paradigm" because he thinks that it is "imprecise," but
it is not that he "do[esn't] believe there is such a thing."

-- Benjamin L. Russell