LOGO-L> Re: Why not a sequential ToonTalk?

[bh@anarres.CS.Berkeley.EDU (Brian Harvey)]

"Ken Kahn" <KenKahn@ToonTalk.com> writes:
> I recall reviewing a
>paper written at Bell Labs that argued persausively that there were very
>large cognitive and collaborative costs to using such rich languages. I
>became convinced that it is hard for most people to switch between different
>programming paradigms at the fine-grain that these languages enable.

I guess I'd like to know whether all paradigms are equally hard in this
sense.  My teaching experience has made me (reluctantly!) conclude that
sequential programming is most natural for most people, and that
functional programming takes more mental effort (although the effort
does pay off dramatically).  Where is concurrent programming on that
scale?  What is the marginal cost of keeping function composition in
a language, on that scale, versus the marginal cost of including
concurrency?

>Also there can be interference between the parts. A Prolog-like, logic
>programming, component has troubles integrating well with an imperative
>sub-language. A pure functional component permits all sorts of program
>transformations and parallel executions that break when integrated with
>languages with side-effects.

I was with you on the logic programming example, but the functional one
seems to me to be a bit of sleight-of-hand; there you are talking about
complexity for the implementor, not cognitive load for the user.

>Yes, the mainstream has just added parallelism to existing frameworks. And
>professional programmers have a hard time understanding and debugging Java
>programs with threads (and Java is one of the better examples of this).
>Computer scientists continue to explore actor, functional, logic-based, and
>constraint-based programming languages that, like ToonTalk, throw out some
>old ideas in order to make progress. In contrast, the computer industry or
>mainstream just tries to graft new things on the old.

I'm convinced that it's difficult to debug programs that combine
concurrency with mutation of shared variables.  I'm not convinced, yet,
that you can't have all of
	* concurrency
	* composition of functions without mutation
	* mutation of local (not shared) variables
all in the same language, without trouble.

P.S.  In Scheme we can do functional, sequential, concurrent, and OOP,
even though Scheme is, in at least one sense, a very simple language.
It doesn't have millions of primitives, like CLOS, or a lot of syntax,
like Java.  We try to teach our students to be able to use several
programming paradigms, but to pay attention to which one they're using.
I suspect that those programmers you mention who had confusingly mixed
styles were handed a Common Lisp manual with no explicit instruction
about paradigms at all.




---------------------------------------------------------------
Please post messages to the Logo forum to logo-l@gsn.org.  Mail
questions about the list administration to logofdn@gsn.org.  To
unsubscribe send    unsubscribe logo-l    to majordomo@gsn.org.